I see I should have used https://clojure.github.io/spec.alpha/clojure.spec.test.alpha-api.html#clojure.spec.test.alpha/check instead. Still, how to best integrate with clojure.test? Something like

(deftest xyz 
  (if-let [f (:failure (st/check ::my-spec)]
    (throw f) 
    (is true)))

@holyjak I’m using this lib for it: https://github.com/borkdude/respeced

so in the context of this question: https://github.com/borkdude/respeced#successful

that function also checks if the sequence of results is not empty

Does anybody have experience they would be willing to share in regard of human readable messages at API boundaries via spec? We've looked at expound(which doesn't fit) and phrase(which could do the job, but I am personally not convinced by the predicate focused approach). It feels that a simpler solution focused around explain-data and a message registry(similar to the one found in expound) would produce a better result. Has anybody implemented/is currently using spec for this purpose?

@boyanb Can you share how you feel expound is not a fit?

It's not really designed with the idea of message formatting for "users". Expound could very easily be enhanced or parts/ideas of it lifted into a library that could fit it. AFAIK, while looking at the code, there were several places where we needed paramtrization/additional control that is currently not available by the public facade of the library,

(had to do with custom printers and expected outputs)

I could probably dig in a little further and find the concrete examples. Are you using it with user facing messages in any way?

I've used expound like this

(defn validate-data [spec data]
  (if (s/valid? spec data)
    :ok
    (if-let [explain-data (s/explain-data spec data)]
      (let [expound-state
            (try
              (expound/expound spec data)
              :ok
              (catch Exception e
                (println "Expound had difficulties using " explain-data)
                :error))]
        (throw (ex-info (if (= expound-state :ok)
                          "Spec error (see stdout)"
                          "Spec error (see explain data)") {:explain explain-data})))
      (throw (ex-info "Specs are in a weird state, as we can't explain why data is invalid" {})))))

But I agree it is not perfect

I've actually used this in a clojurescript environment (using with-out-str). Worked pretty will when you do a validation on every key change

Yes

@boyanb We had a similar problem. We wanted to spec our API using Clojure Spec but we didn't want to expose Spec's error messages to our users (most people are not used to seeing error messages in that format). This immediately meant Expound was out of the question (too similar to Spec). I looked at Phrase but it seemed like you'd need to duplicate some code to get error messages. I didn't really like that. The overall approach Phrase took made sense -- take the output of explain-data, match it, and convert it to error messages. The matching part seemed like a perfect fit for core.match. So I took that direction and wrote https://github.com/Provisdom/user-explain. I didn't have time to write docs for it 😞 IMO the library is much more general than Phrase due to all the features of core.match. It's also pretty simple -- only 75 LOC 🙂

our implementation was with-out-str exactly.

(when with expound). In the end, we still didn't have the formatting we wanted. Main point is, underlying users are really not familiar with anything clojure and shouldn't care about implemenmtation and in the end we needed fine grained control to explain-data to be able to format path within spec + spec message as we needed.

@kenny - what you describe matches exactly our needs. I'll take a look.