       (om/app-state r) => state
       (om/force-root-render! r) => (reset! rendered true)
       (om/merge! r resp) => (assertions
-                                    "updates the react key to force full DOM re-render"
-                                    (contains? resp :ui/react-key) => true)
+                              "updates the react key to force full DOM re-render"
+                              (contains? resp :ui/react-key) => true)
       (dfi/set-global-loading r) => (reset! globally-marked true)
 
       (error-cb response items)

                                         (is (= (om/get-query Item) (:query params)))))

              (df/load-data 'reconciler (om/get-query Item)
                                 :ident [:item/id 99]
                                 :params :params
                                 :without :without
                                 :post-mutation 'foo
                                 :fallback 'bar))

    (component "when requesting data for a collection"
      (when-mocking
        (om/transact! c tx) => (let [params (-> tx first second)]
                                 (behavior "directly uses the query."
                                   (is (= [{:items (om/get-query Item)}] (:query params)))))

        (df/load-data 'reconciler [{:items (om/get-query Item)}]))))

  (component "Loading a collection/singleton from within another mutation"
    (let [app-state (atom {})]

  (component "Loading a field within a component"
    (let [query (om/get-query Item)]
      (provided "properly calls transact"
                (om/get-ident c) =2x=> [:item/by-id 10]
                (om/get-query c) =1x=> query
                (om/transact! c tx) =1x=> (let [params (-> tx first second)
                                                follow-on-reads (set (-> tx rest))]
                                            (assertions
                                              "includes :ui/loading-data in the follow-on reads"
                                              (contains? follow-on-reads :ui/loading-data) => true
                                              "includes ident of component in the follow-on reads"
                                              (contains? follow-on-reads [:item/by-id 10]) => true
                                              "does the transact on the component"
                                              c => 'component
                                              "includes the component's ident in the marker."
                                              (:ident params) => [:item/by-id 10]
                                              "focuses the query to the specified field."
                                              (:query params) => [{:comments [:db/id :title {:author [:db/id :username :name]}]}]
                                              "includes the parameters."
                                              (:params params) => {:sort :by-name}
                                              "includes the subquery exclusions."
                                              (:without params) => #{:excluded-attr}
                                              "includes the post-processing callback."
                                              (:post-mutation params) => 'foo
                                              "includes the error fallback"
                                              (:fallback params) => 'bar))

                (df/load-field 'component :comments
                               :without #{:excluded-attr}
