com.wsscode.pathom.connect.test — com.wsscode/pathom 2.3.0-alpha10

add-subsets clj/s

(add-subsets {:com.wsscode.pathom.connect.test/keys [multi-args] :as a} b)

async-resolve-fn clj/s

(async-resolve-fn {{:com.wsscode.pathom.connect/keys [output]}
                     :com.wsscode.pathom.connect/resolver-data
                   :as env}
                  _)

bank-add clj/s

(bank-add {:com.wsscode.pathom.connect.test/keys [bank-ignore]
           :as env
           :or {bank-ignore #{:com.wsscode.pathom.core/not-found}}}
          a
          b)

Adds new information to a data bank, the data bank is feed by resolver outputs and is used to feed in as input to call other resolvers.

call-add clj/s

(call-add env a b)

collect-multi-args clj/s

(collect-multi-args indexes)

Collect inputs with more than one attribute from the index.

console-print-reporter clj/s multimethod

count-failed-calls clj/s

(count-failed-calls env s)

count-success-calls clj/s

(count-success-calls env s)

depth-print clj/s

(depth-print {:com.wsscode.pathom.connect.test/keys [depth]} & more)

diff-data-shapes clj/s

(diff-data-shapes a b)

Return the query shape differece.

discover-data clj/s

(discover-data env {:com.wsscode.pathom.connect/keys [input]})

Pick a new input for a resolver from the data bank.

dissoc-stats-keys clj/s

(dissoc-stats-keys data-bank)

expand-output-tree clj/s

(expand-output-tree indexes)

Connect normaly only indexes the direct root attributes for scan fetching. But for test discovery we also want the nested to be available as options during parsing. This function brings the nested items to top level.

find-join-value clj/s

(find-join-value q k)

inc* clj/s

(inc* x)

input-list clj/s

(input-list {:com.wsscode.pathom.connect.test/keys [data-bank]}
            {:com.wsscode.pathom.connect/keys [input]}
            in-data)

log! clj/s

(log! {:com.wsscode.pathom.connect.test/keys [data-bank]}
      {:com.wsscode.pathom.connect/keys [sym]}
      {:keys [in out]})

merge-mismatch clj/s

(merge-mismatch {:com.wsscode.pathom.connect.test/keys [out-cumulative]}
                {:com.wsscode.pathom.connect/keys [output]}
                out)

now clj/s

(now)

parser clj/s

parser-env clj/s

prepare-environment clj/s

(prepare-environment {:com.wsscode.pathom.connect/keys [indexes]
                      :com.wsscode.pathom.connect.test/keys [data-bank]
                      :as env})

process-multi-run! clj/s

(process-multi-run! {:com.wsscode.pathom.connect.test/keys
                       [data-bank target-call-count max-error-retry]
                     :or {target-call-count 5 max-error-retry 10}
                     :as env}
                    sym)

reduce-first clj/s

(reduce-first col)

report clj/s

(report {:com.wsscode.pathom.connect.test/keys [report-fn] :as env} event data)

resolve-attr clj/s

(resolve-attr {:com.wsscode.pathom.connect.test/keys [data-bank force-seek?]
               :as env}
              attr)

Find a value for an attribute.

resolve-fn clj/s

(resolve-fn {{:com.wsscode.pathom.connect/keys [output]}
               :com.wsscode.pathom.connect/resolver-data}
            _)

resolver-calls clj/s

(resolver-calls {:com.wsscode.pathom.connect.test/keys [data-bank]} s)

return-extra-attributes clj/s

(return-extra-attributes {:com.wsscode.pathom.connect/keys [output]} out)

seek-attr clj/s

(seek-attr {:com.wsscode.pathom.connect.test/keys [data-bank resolver-trace
                                                   depth]
            :com.wsscode.pathom.connect/keys [indexes]
            :or {depth 0}
            :as env}
           attr)

Try to run more resolvers to get more attributes of type attr.

silent-reporter clj/s

(silent-reporter _ _ _)

I report nothing!

success-call? clj/s

(success-call? x)

test-index clj/s

(test-index env)

test-index* clj/s

(test-index* {:com.wsscode.pathom.connect/keys [indexes] :as env})

test-resolver clj/s

(test-resolver env {:com.wsscode.pathom.connect/keys [sym]})

Test a single resolver.

test-resolver* clj/s

(test-resolver* {:com.wsscode.pathom.connect.test/keys [data-bank force-seek?]
                 :as env}
                {:com.wsscode.pathom.connect/keys [sym] :as resolver})

(test-resolver* {:com.wsscode.pathom.connect.test/keys [data-bank] :as env}
                {:com.wsscode.pathom.connect/keys [sym] :as resolver}
                input)

Test a resolver.

unreachable clj/s

(unreachable {:com.wsscode.pathom.connect.test/keys [data-bank]} k)

Mark attribute k as unreachable on db. Returns ::unreachable.

vector->set clj/s

(vector->set x)

Recursively converts all vectors in sets.