This is fun. Using a pull-query to generate specs means I can generate test data for UI views based on the pull query they use. https://gist.github.com/olivergeorge/da6487fc60c67b79ba082bc807072e43 This still requires table and field specs based on something like this: https://gist.github.com/olivergeorge/468464ce82b8da486736fe725a4b6ff8

Is there a JIRA issue open for spec coercions (in the same way that schema does them)? I’m aware of conform, but that isn’t quite the same

there is no plan to add that

Rich sees them as separate concerns

I'm presuming I'm doing something wrong and that there is a function in core that will do this, but this bit of code is working for me to integrate spec tests into my normal clojure.test flow

(defn passes? [sym]
  (-> sym
      stest/check
      first
      :clojure.spec.test.check/ret
      :result))

(t/deftest conformer-testing
  (t/testing "Checking the conformer"
    (t/is (true? (passes? `sut/my-specced-func)))))

I've elided the bit where I define the :args :ret and :fn for my-specced-func

is there something that does the same as passes? and is true? really the right way of putting this into t/is ? Success and failure both return truthy values which is why I'm using it atm

@otfrom Here's what @bahulneel and I came up with: https://gist.github.com/jmglov/30571ede32d34208d77bebe51bb64f29

I have a record that implements a protocol. How do I spec this?

When I try to gen/sample some deeply nested spec, I get a "Couldn't satisfy such-that predicate after 100 tries." exception with no mention of the spec or predicate in question. Is there a good way to figure out which spec caused this?

So far, my only hope is a binary search by running gen/sample on the sub-specs until I find the offender. 😞

@jmglov I had this problem also. I had to eyeball my specs and try exercising individual ones. In the end, it's usually ones that use and and limit the valid input to some "shape". To fix these I use with gen, an example I stole is here: https://github.com/nwjsmith/datomic-spec/blob/master/src/datomic_spec.clj#L6

@bahulneel Yes, that was exactly it. My offending one turned out to be (s/and map? empty?). I changed it to #{{}}. 🙂

nice

@jmglov it's worth noting that, in that case (s/and empty? map?) will also work fine

Of course! That's actually nicer to read, I think.

Thanks!

the only issue is that the explanation would fail empty? before map? so the message may not be as useful

user> (clojure.spec/explain (clojure.spec/and empty? map?) [1])
val: [1] fails predicate: empty?
nil
user> (clojure.spec/explain (clojure.spec/and empty? map?) [])
val: [] fails predicate: map?
nil
user> (clojure.spec/explain (clojure.spec/and empty? map?) {1 2})
val: {1 2} fails predicate: empty?
nil
user> 

But it's better than the alternative:

user> (clojure.spec/explain #{{}} {1 2})
val: {1 2} fails predicate: :clojure.spec/unknown
nil
user> (clojure.spec/explain #{{}} [])
val: [] fails predicate: :clojure.spec/unknown
nil
user> 

This works better:

user> (clojure.spec/def ::empty-map #{{}})
:user/empty-map
user> (clojure.spec/explain ::empty-map {1 2})
val: {1 2} fails spec: :user/empty-map predicate: #{{}}
nil
user> 

(also naming (s/and empty? map?) gives a similar level of clarity)

any known attempt to generate json-schema from specs?

there's a ring-swagger fork that tried, but it's not there yet

@mpenet would we easy with records, https://groups.google.com/forum/m/#!topic/clojure-dev/9EjTvxPPaGQ

I am not really interested in the conform part right now

I just need generating decent json-schemas from specs

@bahulneel Nice!

ok, not there yet. It would be easy to cook up a working prototype of the conversion from existing spikes, but still gaps to make it robust and extendable. Good thing that, there are smarter people here :)

Spectrums parse-spec might be a good way for it.

Isnt it possible just to gen from s/form?

It s a one time thing so perf doesnt matter

Hmm... there was one version with s/form & core.match, can't recall what was the problem with it. Maybe just not finished.

actually, it could be extended too, with multimethod on the spec symbol. Ping @miikka.

I have something along these lines already, even tho the multimethod is kinda useless ultimately, it can be closed

@jmglov: regarding protocol implementations - I read (on the mailing list, I think), that directly spec’ing protocol fns wasn’t supported, and the recommendation was to make the protocol fns “private”, provide wrapper fns, and spec those. This worked fine for me, especially because I had some common logic that fit nicely in the wrapper fns.

@bhagany I'm not trying the spec the protocol functions themselves, but rather an argument to a function that should implement a certain protocol. i.e.

(defprotocol Database
  (read-thing [this id])
  (store-thing [this thing]))

...

(defn do-stuff [db updates]
  (let [thing (database/read-thing (:id updates))]
    (-> thing
        (merge updates)
        database/store-thing)))

(s/fdef do-stuff
        :args (s/cat :db #(implements? Database %)
                     :updates (s/keys :req [::thing/id]
                                      :opt [::thing/name]))
        :ret any?)

you can use satisfies?

@mpenet Exactly what I needed! Thanks!

it gets more tricky if you want to add gen support

No need for now, thank goodness.

I’m trying to run “free” generative tests in cljs, using doo, but it seems as though the registry is not being populated in my test build. I’m importing a namespace that defines some named specs, and I can run the functions in that namespace, but clojure.spec.test/check and checkable-syms are both empty. However, in my figwheel repl, the registry is populated as I would expect. Any ideas what I might be missing?

I should also add that clojure.spec.test/enumerate-namespace does see the fns that are spec’d in my test build

and also that I can (s/valid? ::some/data-spec data) in my test build. It seems like only fn specs are missing.

Possibly stupid question: why is s/fdef not called s/defn ?

because that’s not what Rich named it

good enough for me 🙂 all hail Master Rich 🙂 (I was asking in case there was some subtlety I’m missing)

having a hard time wrapping my head around writing generators, how would i write a generator for a set of distinct strings?

there is a function, it might be called one-of

https://github.com/clojure/test.check/blob/master/src/main/clojure/clojure/test/check/generators.cljc#L272-L289

oh, sorry, no wrong one

https://github.com/clojure/test.check/blob/master/src/main/clojure/clojure/test/check/generators.cljc#L337-L348

elements

i tried (gen/fmap set (gen/vector gen/string))

oh, I misunderstood

there is a generator for sets

so (gen/set gen/string)

excellent that did it

you may need to do some voodoo connect that to spec, I haven't looked too much at how test.check and spec are tied together

i just had to do with-gen

really easy

here’s another one: any idea how to generate long strings?

say > 200 chars?

if you run more generative test iterations, the size of the strings will get larger, but it would likely be easier to create a special purpose larger string generator

which maybe some combination of resized and the string generator would help you do

https://github.com/clojure/test.check/blob/master/src/main/clojure/clojure/test/check/generators.cljc#L233-L240

(gen/set (gen/resized 200 gen/string))

resized looks good

there's sooooo much stuff in the clojure.test.check.generators namespace, trying to internalise all that is the one thing I'm not looking forward to when we start using spec

the docs don’t mention everything so you gotta dig into the sources

that said, using spec with devcards is kicking ass right now for building om ui's

in many cases it’s easier to just gen from a spec

(s/gen (s/coll-of string? :kind set?))

@liamd ^^

for some specs i get {:message "Couldn't satisfy such-that predicate after 100 tries.", :data {}}

if you are and’ing specs with fairly restrictive filters, you’re likely to run into this

this is discussed (plus making custom generators) in http://clojure.org/guides/spec if you haven’t seen that yet

yeah i’ve read that over, seems the solution is to write your own generators and then use with-gen which works great

i’m already re-using a good amount of generators for things like certain numbers and strings with various properties

one thing is that error won’t tell me which generator it’s talking about

which is… confusing

yes, I think that’s worth improving

I don’t think anyone has actually filed a ticket about it, but I would be in favor of improving that

is that specific to the cljs implentation or spec in general?

or i guess that’s test.check

it is, but I suspect it could be wrapped somehow in spec

haven’t looked at it

yeah i suppose you’d want to tie it back to your namespaced key

I'm having a problem with generators.

(def col-gen
  (gen/fmap #(->> % (apply str) str/upper-case keyword)
    (gen/vector gen/char-alpha)))


(s/def :cell/col (s/and simple-keyword? (comp (set util/alphabet) name)))

Other question, how can I make a generator from a set?

what namespace is gen?

clojure.spec.gen

I bet you need to invoke gen/char-alpha

the things in clojure.spec.gen aren't actually generators, they are 0 argument functions that you invoke to get a generator

Thanks, that worked

And how can I make a generator from a set?

you have a set of elements and you want a generator to pick elements from it?

Yeah

gen/elements

or of course just (s/gen #{:a :b :c})

people do not leverage gens from specs enough imo

that should be your first choice

then stuff in spec.gen, then stuff in test.check

or test.chuck etc

so (s/gen (s/spec number?)) instead of gen/number or whatever?

just (s/gen number?)

but yes

@alexmiller about that case, is it normal for

(clojure.test.check.generators/sample (cljs.spec/gen #{true false}))

(true true true true true true true true true true)

well any set with falsey elements is going to be a bad time

that’s kind of a special case - it will return falsey elements which is the signal that the value doesn’t match the spec

in this case (s/gen boolean?) will be better

Oh, I get it !

and if you want to support nil,true,false then (s/gen (s/nilable boolean?))

Thank you ! I had some bad time with (s/gen boolean?) in ClojureScript, throwing an error. I figured it out with with-gen and (gen/elements #{true false}). I don't know if it's a known bug or not btw…

sounds like a bug

you might ask in #clojurescript to see what @dnolen thinks

@ggaillard it should work, make sure you are on the latest 1.9.229, if it still doesn’t work, file an issue in JIRA

You are quick! I didn't had time to post in #clojurescript 🙂 Thank you, I'll check that.

I was using 1.9.216, 1.9.229 fixed it. Sorry for that 😕

The clojure.spec/nilable docs say it takes a pred, but it also seems to work if it's passed a spec. Is that behavior I can rely on?