test(rtc): add case :add-task-properties-to-block1

src/main/frontend/worker/rtc/skeleton.cljs

@@ -73,7 +73,8 @@
                                      :db-ident-blocks db-ident-blocks
                                      :schema-version (get-schema-version db)}))]
       (if-let [remote-ex (:ex-data r)]
-        (throw (ex-info "Unavailable2" {:remote-ex remote-ex}))
+        (do (prn {:remote-ex remote-ex})
+            (throw (ex-info "Unavailable2" {:remote-ex remote-ex})))
         (let [server-only-db-ident-blocks (some-> (:server-only-db-ident-blocks r)
                                                   ldb/read-transit-str)]
           (when (seq server-only-db-ident-blocks)

src/rtc_e2e_test/client_steps.cljs

@@ -11,7 +11,7 @@
             [logseq.outliner.batch-tx :as batch-tx]
             [missionary.core :as m]))
 
-(def step0
+(def ^:private step0
   {:client1
    (m/sp
      (let [conn (helper/get-downloaded-test-conn)
@@ -33,7 +33,7 @@
             (set (map helper/simplify-client-op (client-op/get-all-ops const/downloaded-test-repo)))))))
    :client2 nil})
 
-(def step1
+(def ^:private step1
   "client1: start rtc, wait page1, client1->remote
   client2: start rtc, wait page1, remote->client2"
   {:client1
@@ -73,7 +73,7 @@
               :block/parent {:db/id (:db/id page1)}}
              (select-keys block1 [:block/title :block/order :block/parent]))))))))})
 
-(def step2
+(def ^:private step2
   "client1: insert 500 blocks, wait for changes to sync to remote
   client2: wait for blocks to sync from remote"
   {:client1
@@ -97,24 +97,62 @@
       (let [conn (helper/get-downloaded-test-conn)
             page (d/pull @conn '[*] [:block/uuid const/page2-uuid])]
         (when-not (:block/uuid page)
-          (throw (ex-info "wait for page to be synced" {:missionary/retry true})))
+          (throw (ex-info "wait page to be synced" {:missionary/retry true})))
         (let [blocks (ldb/sort-by-order (ldb/get-page-blocks @conn (:db/id page)))]
           (is (= 500 (count blocks)))
           (is (= (map #(str "x" %) (range 500))
                  (map :block/title blocks)))))))})
 
+(def ^:private step3
+  "client1:
+  1. add #task properties to block1 (`const/block1-uuid`)
+  2. wait to be synced
+  client2:
+  1. wait the block&its properties to be synced"
+  {:client1
+   (m/sp
+     (let [conn (helper/get-downloaded-test-conn)
+           tx-data (const/tx-data-map :add-task-properties-to-block1)]
+       (batch-tx/with-batch-tx-mode conn {:e2e-test const/downloaded-test-repo :skip-store-conn true}
+         (d/transact! conn tx-data))
+       (let [r (m/? (m/timeout
+                     (m/reduce (fn [_ v]
+                                 (when (and (= :rtc.log/push-local-update (:type v))
+                                            (empty? (client-op/get-all-ops const/downloaded-test-repo)))
+                                   (is (nil? (:ex-data v)))
+                                   (reduced v)))
+                               rtc-log-and-state/rtc-log-flow)
+                     10000 :timeout))]
+         (is (not= :timeout r)))))
+   :client2
+   (m/sp
+     (let [conn (helper/get-downloaded-test-conn)
+           block1 (d/pull @conn
+                          [{:block/tags [:db/ident]}
+                           {:logseq.task/status [:db/ident]}
+                           {:logseq.task/deadline [:block/journal-day]}]
+                          [:block/uuid const/block1-uuid])]
+       (when-not (:logseq.task/status block1)
+         (throw (ex-info "wait block1's task properties to be synced" {:missionary/retry true})))
+       (is (= {:block/tags [{:db/ident :logseq.class/Task}],
+               :logseq.task/status {:db/ident :logseq.task/status.done}
+               :logseq.task/deadline {:block/journal-day 20240907}}
+              block1))))})
+
 (defn- wrap-print-step-info
   [steps client]
   (map-indexed
    (fn [idx step]
      (m/sp
-       (println (str "[" client "]") "start step" idx)
-       (some-> (get step client) m/?)
-       (println (str "[" client "]") "end step" idx)))
+      (println (str "[" client "]") "start step" idx)
+      (some-> (get step client) m/?)
+      (println (str "[" client "]") "end step" idx)))
    steps))
 
+(def ^:private all-steps [step0 step1 step2 step3])
+
 (def client1-steps
-  (wrap-print-step-info [step0 step1 step2] :client1))
+  (wrap-print-step-info all-steps :client1))
 
 (def client2-steps
-  (wrap-print-step-info [step0 step1 step2] :client2))
+  (wrap-print-step-info all-steps :client2))

src/rtc_e2e_test/const.cljs

@@ -58,4 +58,19 @@
                  :block/parent "page"
                  :block/order order
                  :block/page "page"})
-              (range 500) (db-order/gen-n-keys 500 "a0" "a1")))})
+              (range 500) (db-order/gen-n-keys 500 "a0" "a1")))
+   :add-task-properties-to-block1
+   [{:db/id "id-0907"
+     :block/uuid #uuid "00000001-2024-0907-0000-000000000000"
+     :block/updated-at 1725455235108
+     :block/created-at 1725455235108
+     :block/journal-day 20240907
+     :block/format :markdown
+     :block/title "Sep 7th, 2024"
+     :block/name "sep 7th, 2024"
+     :block/type "journal"}
+    {:block/uuid block1-uuid
+     :block/updated-at 1725454876718
+     :block/tags :logseq.class/Task
+     :logseq.task/status :logseq.task/status.done
+     :logseq.task/deadline "id-0907"}]})