Is there a good doc/faq/something on using spec's ability to generate mock data? Generating a string like "001212314" in particular? (meaning, n length, chars consisting of just 0-9?

spec itself does not really have something like that built in

you can use fmap to build a set of characters, then apply str to them

or use the regex gen support in the test.chuck library

I had been using test.chuck, but was curious if there was a more spec-native solution. thanks, I'll keep going with what I have!

test.chuck is rad

question, when i run (clojure.spec.test/check 'merge-users {:clojure.spec.test.check/opts {:num-tests 15 :max-size 2}}) it seems the num-tests option seems to be ignored. Am I passing the options for quick-check wrong? or is this to be expected and should I address my own expectations? 🙂

where I use the backtick instead of the quote (to help in markdown slack formatting)

(stest/check `foo {:clojure.spec.test.check/opts {:num-tests 1}})

In Clojure spec, how could I generate symbols or strings of max length 2 that contain only lowercased alphabetic characters? This works, but maybe it can be simplified?

(s/def ::varname
  (s/with-gen symbol?
    #(gen/fmap (fn [[i j l]]
                 (symbol
                  (str/lower-case (.substring
                                   (str i j)
                                   0 l))))
               (gen/tuple (gen/char-alpha)
                          (gen/char-alpha)
                          (gen/choose 1 2)))))

min length 1?

yes

I don't think that's terrible

(s/def ::varname
  (s/with-gen symbol?
              #(gen/fmap (fn [characters]
                           (symbol
                             (string/lower-case
                               (apply str characters))))
                         (gen/vector (gen/char-alphanumeric)
                                     1
                                     2))))

With spec/keys (or spec in general), what’s the best way to express: One and only one of the keys ::foo or ::bar is required?

Or alternatively “Either ::foo or ::bar or both is required”

(s/keys :req [(or ::foo ::bar)]) and then and'd with a spec to enforce only one if you want that

Thanks, let me try that

The :req key vector supports 'and' and 'or' for key groups:
(s/keys :req [::x ::y (or ::secret (and ::user ::pwd))] :opt [::z])

I think this is exactly what I was looking for 👍

@nwjsmith Thanks 🙂

@nwjsmith https://github.com/borkdude/aoc2015_day7/commit/936987c86451d9032e28e6151f0dd061ab58a0be

Crazy, I was just reading your blog post. Great stuff!

How are you folks debugging Couldn't satisfy such-that predicate errors?