Extract chunk-random-string in random.clj

...from near identical alphabetic-string and random-ascii-string.

Also adds a bit of test coverage for these functions and some of their
adjacents.

Signed-off-by: Josh Partlow <jpartlow@glatisant.org>

Author: jpartlow

src/puppetlabs/puppetdb/random.clj

@@ -10,51 +10,43 @@
 (def ^{:doc "Convenience for java.util.Random"}
   random (java.util.Random.))
 
-(defn- alphabetic-string
-  "Generate a random alphabetic string of the given length.
-
-   Chunks requests to stay within the BouncyCastle FIPS DRBG per-request limit
-   of 262144 bits. Apache Commons Lang3's CachedRandomBits allocates
-   (count * gapBits + 3) / 5 + 10 bytes per call. For nextAlphabetic
-   (A-Z + a-z = 52 chars, gapBits = ceil(log2(52)) = 6) the maximum count per call is:
-   (count * 6 + 3) / 5 + 10 <= 32768  =>  count <= 27298"
-  [length]
-  (let [fips-max-chunk 27298
-        ^RandomStringUtils secure-random (RandomStringUtils/secure)]
-    (if (<= length fips-max-chunk)
-      (.nextAlphabetic secure-random length)
-      ;; Build incrementally to avoid intermediate vectors/strings for large values.
-      (let [^StringBuilder builder (StringBuilder. length)]
-        (loop [remaining length]
-          (if (<= remaining 0)
-            (.toString builder)
-            (let [chunk-size (min remaining fips-max-chunk)]
-              (.append builder (.nextAlphabetic secure-random chunk-size))
-              (recur (- remaining chunk-size)))))))))
-
-(defn random-ascii-string
-  "Generate a random ASCII string of the given length.
+(defn- chunked-random-string
+  "Generate a random alphabetic or ascii string of the given length.
 
    Chunks requests to stay within the BouncyCastle FIPS DRBG per-request limit
    of 262144 bits (32768 bytes). Apache Commons Lang3's RandomStringUtils
    allocates a CachedRandomBits with size = (count * gapBits + 3) / 5 + 10
-   bytes. For nextAscii (ASCII range 32-127, gap=95, gapBits=7) the maximum
-   count that keeps the cache within 32768 bytes is:
-     (count * 7 + 3) / 5 + 10 <= 32768  =>  count <= 23398"
-  [length]
-  (let [fips-max-chunk 23398
-        ^RandomStringUtils secure-random (RandomStringUtils/secure)]
+   bytes.
+
+   For nextAscii (ASCII range 32-127, gap=95, gapBits=7)
+   the maximum count that keeps the cache within 32768 bytes is:
+     (count * 7 + 3) / 5 + 10 <= 32768  =>  count <= 23398
+
+   For nextAlphabetic (A-Z + a-z = 52 chars, gapBits = ceil(log2(52)) = 6)
+   the maximum count per call is:
+     (count * 6 + 3) / 5 + 10 <= 32768  =>  count <= 27298"
+  [method length]
+  (let [^RandomStringUtils secure-random (RandomStringUtils/secure)
+        [gen-fn fips-max-chunk] (case method
+                                  :ascii    [#(.nextAscii ^RandomStringUtils secure-random %) 23398]
+                                  :alphabetic [#(.nextAlphabetic ^RandomStringUtils secure-random %) 27298])]
     (if (<= length fips-max-chunk)
-      (.nextAscii secure-random length)
+      (gen-fn length)
       ;; Build incrementally to avoid intermediate vectors/strings for large values.
       (let [^StringBuilder builder (StringBuilder. length)]
         (loop [remaining length]
           (if (<= remaining 0)
             (.toString builder)
             (let [chunk-size (min remaining fips-max-chunk)]
-              (.append builder (.nextAscii secure-random chunk-size))
+              (.append builder (gen-fn chunk-size))
               (recur (- remaining chunk-size)))))))))
 
+(defn- alphabetic-string [length]
+  (chunked-random-string :alphabetic length))
+
+(defn random-ascii-string [length]
+  (chunked-random-string :ascii length))
+
 (defn random-string
   "Generate a random string of optional length"
   ([] (alphabetic-string (inc (rand-int 10))))

test/puppetlabs/puppetdb/random_test.clj

@@ -3,6 +3,7 @@
    [clojure.test :refer :all]
    [puppetlabs.puppetdb.random
     :refer [distribute
+            random-ascii-string
             random-bool
             random-node-name
             random-pp-path
@@ -16,24 +17,47 @@
 
 (deftest test-random-string
   (testing "should return a string of specified length"
+    (is (>= 10 (count (random-string))))
     (is (= 8 (count (random-string 8))))
     (is (= 30 (count (random-string 30))))
     (is (= 100 (count (random-string 100)))))
 
+  (testing "should only contain alphabetic characters"
+    (is (re-matches #"\A[a-zA-Z]+\z" (random-string)))
+    (is (re-matches #"\A[a-zA-Z]{100}\z" (random-string 100))))
+
   (testing "should only accept a positive integer"
     (is (thrown? IllegalArgumentException (random-string -1)))
     (is (thrown? ClassCastException (random-string "asdf")))))
 
 (deftest test-random-string-alpha
   (testing "should return a string of specified length"
+    (is (>= 10 (count (random-string-alpha))))
     (is (= 8 (count (random-string-alpha 8))))
     (is (= 30 (count (random-string-alpha 30))))
     (is (= 100 (count (random-string-alpha 100)))))
 
+  (testing "should only contain lowercase alphabetic characters"
+    (is (re-matches #"\A[a-z]+\z" (random-string-alpha)))
+    (is (re-matches #"\A[a-z]{100}\z" (random-string-alpha 100))))
+
   (testing "should only accept a positive integer"
     (is (thrown? IllegalArgumentException (random-string-alpha -1)))
     (is (thrown? ClassCastException (random-string-alpha "asdf")))))
 
+(deftest test-random-ascii-string
+  (testing "should return a string of specified length"
+    (is (= 8 (count (random-ascii-string 8))))
+    (is (= 30 (count (random-ascii-string 30))))
+    (is (= 100 (count (random-ascii-string 100)))))
+
+  (testing "should only contain ascii characters"
+    (is (re-matches #"\A[\x20-\x7E]{100}\z" (random-ascii-string 100))))
+
+  (testing "should only accept a positive integer"
+    (is (thrown? IllegalArgumentException (random-ascii-string -1)))
+    (is (thrown? ClassCastException (random-ascii-string "asdf")))))
+
 (deftest test-random-bool
   (testing "should return a boolean"
     (is (boolean? (random-bool)))))