coop/rose-ash
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix 4 pre-existing test failures in deps and orchestration

Browse Source 
component-pure?: was trusting empty component-io-refs as "definitely pure",
bypassing transitive dependency scan. Now only short-circuits on non-empty
direct IO refs; empty/nil falls through to transitive-io-refs-walk.

render-target: env-get threw on unknown component names. Now guards with
env-has? and returns "server" for missing components.

offline-aware-mutation test: execute-action was a no-op stub that never
called the success callback. Added mock that invokes success-fn so
submit-mutation's on-complete("confirmed") fires.

page-render-plan: was downstream of component-pure? bug, now passes.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
giles
2026-04-02 13:30:03 +00:00
parent 4ef05f1a4e
commit 14388913c9
2 changed files with 365 additions and 515 deletions
Download Patch File Download Diff File Expand all files Collapse all files

242
web/tests/test-orchestration.sx
View File

@@ -1,170 +1,142 @@
;; ==========================================================================
;; test-orchestration.sx — Tests for orchestration.sx Phase 7c + 7d
;;
;; Requires: test-framework.sx loaded first.
;; Platform functions mocked by test runner:
;; now-ms, log-info, log-warn, execute-action, try-rerender-page
;; ==========================================================================
;; --------------------------------------------------------------------------
;; 1. page-data-cache — basic cache operations
;; --------------------------------------------------------------------------
(defsuite "page-data-cache"
(deftest "cache-key bare page name"
(defsuite
"page-data-cache"
(deftest
"cache-key bare page name"
(assert-equal "my-page" (page-data-cache-key "my-page" nil)))
(deftest "cache-key with params"
(let ((key (page-data-cache-key "my-page" {"id" "42"})))
(deftest
"cache-key with params"
(let
((key (page-data-cache-key "my-page" {:id "42"})))
(assert-equal "my-page:id=42" key)))
(deftest "cache-set then get"
(let ((key "test-cache-1"))
(page-data-cache-set key {"items" (list 1 2 3)})
(let ((result (page-data-cache-get key)))
(deftest
"cache-set then get"
(let
((key "test-cache-1"))
(page-data-cache-set key {:items (list 1 2 3)})
(let
((result (page-data-cache-get key)))
(assert-equal (list 1 2 3) (get result "items")))))
(deftest "cache miss returns nil"
(deftest
"cache miss returns nil"
(assert-nil (page-data-cache-get "nonexistent-key"))))
;; --------------------------------------------------------------------------
;; 2. optimistic-cache-update — predicted mutation with snapshot
;; --------------------------------------------------------------------------
(defsuite "optimistic-cache-update"
(deftest "applies mutator to cached data"
(let ((key "opt-test-1"))
;; Seed the cache
(page-data-cache-set key {"count" 10})
;; Apply optimistic mutation
(let ((predicted (optimistic-cache-update key
(fn (data) (merge data {"count" 11})))))
(defsuite
"optimistic-cache-update"
(deftest
"applies mutator to cached data"
(let
((key "opt-test-1"))
(page-data-cache-set key {:count 10})
(let
((predicted (optimistic-cache-update key (fn (data) (merge data {:count 11})))))
(assert-equal 11 (get predicted "count")))))
(deftest "updates cache with prediction"
(let ((key "opt-test-2"))
(page-data-cache-set key {"count" 5})
(optimistic-cache-update key (fn (data) (merge data {"count" 6})))
;; Cache now has predicted value
(let ((cached (page-data-cache-get key)))
(deftest
"updates cache with prediction"
(let
((key "opt-test-2"))
(page-data-cache-set key {:count 5})
(optimistic-cache-update key (fn (data) (merge data {:count 6})))
(let
((cached (page-data-cache-get key)))
(assert-equal 6 (get cached "count")))))
(deftest "returns nil when no cached data"
(let ((result (optimistic-cache-update "no-such-key"
(fn (data) (merge data {"x" 1})))))
(deftest
"returns nil when no cached data"
(let
((result (optimistic-cache-update "no-such-key" (fn (data) (merge data {:x 1})))))
(assert-nil result))))
;; --------------------------------------------------------------------------
;; 3. optimistic-cache-revert — restore from snapshot
;; --------------------------------------------------------------------------
(defsuite "optimistic-cache-revert"
(deftest "reverts to original data"
(let ((key "revert-test-1"))
(page-data-cache-set key {"count" 10})
(optimistic-cache-update key (fn (data) (merge data {"count" 99})))
;; Cache now has 99
(defsuite
"optimistic-cache-revert"
(deftest
"reverts to original data"
(let
((key "revert-test-1"))
(page-data-cache-set key {:count 10})
(optimistic-cache-update key (fn (data) (merge data {:count 99})))
(assert-equal 99 (get (page-data-cache-get key) "count"))
;; Revert
(let ((restored (optimistic-cache-revert key)))
(let
((restored (optimistic-cache-revert key)))
(assert-equal 10 (get restored "count"))
;; Cache is back to original
(assert-equal 10 (get (page-data-cache-get key) "count")))))
(deftest "returns nil when no snapshot"
(deftest
"returns nil when no snapshot"
(assert-nil (optimistic-cache-revert "never-mutated"))))
;; --------------------------------------------------------------------------
;; 4. optimistic-cache-confirm — discard snapshot
;; --------------------------------------------------------------------------
(defsuite "optimistic-cache-confirm"
(deftest "confirm clears snapshot"
(let ((key "confirm-test-1"))
(page-data-cache-set key {"val" "a"})
(optimistic-cache-update key (fn (data) (merge data {"val" "b"})))
;; Confirm — accepts the optimistic value
(defsuite
"optimistic-cache-confirm"
(deftest
"confirm clears snapshot"
(let
((key "confirm-test-1"))
(page-data-cache-set key {:val "a"})
(optimistic-cache-update key (fn (data) (merge data {:val "b"})))
(optimistic-cache-confirm key)
;; Revert should now return nil (no snapshot)
(assert-nil (optimistic-cache-revert key))
;; Cache still has optimistic value
(assert-equal "b" (get (page-data-cache-get key) "val")))))
;; --------------------------------------------------------------------------
;; 5. offline-is-online? / offline-set-online! — connectivity tracking
;; --------------------------------------------------------------------------
(defsuite "offline-connectivity"
(deftest "initially online"
(assert-true (offline-is-online?)))
(deftest "set offline"
(defsuite
"offline-connectivity"
(deftest "initially online" (assert-true (offline-is-online?)))
(deftest
"set offline"
(offline-set-online! false)
(assert-false (offline-is-online?)))
(deftest "set back online"
(deftest
"set back online"
(offline-set-online! true)
(assert-true (offline-is-online?))))
;; --------------------------------------------------------------------------
;; 6. offline-queue-mutation — queue entries when offline
;; --------------------------------------------------------------------------
(defsuite "offline-queue-mutation"
(deftest "queues an entry"
;; Seed cache so optimistic update works
(let ((key (page-data-cache-key "notes" nil)))
(page-data-cache-set key {"items" (list "a" "b")})
(let ((entry (offline-queue-mutation "add-note"
{"text" "c"}
"notes" nil
(fn (data) (merge data {"items" (list "a" "b" "c")})))))
(defsuite
"offline-queue-mutation"
(deftest
"queues an entry"
(let
((key (page-data-cache-key "notes" nil)))
(page-data-cache-set key {:items (list "a" "b")})
(let
((entry (offline-queue-mutation "add-note" {:text "c"} "notes" nil (fn (data) (merge data {:items (list "a" "b" "c")})))))
(assert-equal "add-note" (get entry "action"))
(assert-equal "pending" (get entry "status")))))
(deftest "pending count increases"
;; Previous test queued 1 entry; count should be >= 1
(deftest
"pending count increases"
(assert-true (> (offline-pending-count) 0))))
(define
execute-action
(fn (action-name payload success-fn error-fn) (success-fn nil)))
;; --------------------------------------------------------------------------
;; 7. offline-aware-mutation — routes by connectivity
;; --------------------------------------------------------------------------
(defsuite "offline-aware-mutation"
(deftest "when online calls submit-mutation path"
(defsuite
"offline-aware-mutation"
(deftest
"when online calls submit-mutation path"
(offline-set-online! true)
(let ((key (page-data-cache-key "test-page" nil)))
(page-data-cache-set key {"v" 1})
;; This will trigger execute-action (mocked) which calls success cb
(let ((status nil))
(offline-aware-mutation "test-page" nil "do-thing" {"x" 1}
(fn (data) (merge data {"v" 2}))
(let
((key (page-data-cache-key "test-page" nil)))
(page-data-cache-set key {:v 1})
(let
((status nil))
(offline-aware-mutation
"test-page"
nil
"do-thing"
{:x 1}
(fn (data) (merge data {:v 2}))
(fn (s) (set! status s)))
;; Mock execute-action calls success immediately
(assert-equal "confirmed" status))))
(deftest "when offline queues mutation"
(deftest
"when offline queues mutation"
(offline-set-online! false)
(let ((key (page-data-cache-key "test-page-2" nil)))
(page-data-cache-set key {"v" 1})
(let ((status nil))
(offline-aware-mutation "test-page-2" nil "do-thing" {"x" 1}
(fn (data) (merge data {"v" 2}))
(let
((key (page-data-cache-key "test-page-2" nil)))
(page-data-cache-set key {:v 1})
(let
((status nil))
(offline-aware-mutation
"test-page-2"
nil
"do-thing"
{:x 1}
(fn (data) (merge data {:v 2}))
(fn (s) (set! status s)))
(assert-equal "queued" status)))
;; Clean up: go back online
(offline-set-online! true)))