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

638
web/deps.sx
View File

@@ -1,459 +1,337 @@
;; ========================================================================== (define
;; deps.sx — Component dependency analysis specification scan-refs
;; :effects ()
;; Pure functions for analyzing component dependency graphs. (fn (node) (let ((refs (list))) (scan-refs-walk node refs) refs)))
;; Used by the bundling system to compute per-page component bundles
;; instead of sending every definition to every page.
;;
;; All functions are pure — no IO, no platform-specific operations.
;; Each host bootstraps this to native code alongside eval.sx/render.sx.
;;
;; From eval.sx platform (already provided by every host):
;; (type-of x) → type string
;; (symbol-name s) → string name of symbol
;; (component-body c) → unevaluated AST of component body
;; (component-name c) → string name (without ~)
;; (macro-body m) → macro body AST
;; (env-get env k) → value or nil
;;
;; New platform functions for deps (each host implements):
;; (component-deps c) → cached deps list (may be empty)
;; (component-set-deps! c d)→ cache deps on component
;; (component-css-classes c)→ pre-scanned CSS class list
;; (regex-find-all pat src) → list of capture group 1 matches
;; (scan-css-classes src) → list of CSS class strings from source
;; ==========================================================================
(define
;; -------------------------------------------------------------------------- scan-refs-walk
;; 1. AST scanning — collect ~component references from an AST node :effects ()
;; -------------------------------------------------------------------------- (fn
;; Walks all branches of control flow (if/when/cond/case) to find (node (refs :as list))
;; every component that *could* be rendered.
(define scan-refs :effects []
(fn (node)
(let ((refs (list)))
(scan-refs-walk node refs)
refs)))
(define scan-refs-walk :effects []
(fn (node (refs :as list))
(cond (cond
;; Symbol starting with ~ → component reference
(= (type-of node) "symbol") (= (type-of node) "symbol")
(let ((name (symbol-name node))) (let
(when (starts-with? name "~") ((name (symbol-name node)))
(when (not (contains? refs name)) (when
(append! refs name)))) (starts-with? name "~")
(when (not (contains? refs name)) (append! refs name))))
;; List → recurse into all elements (covers all control flow branches)
(= (type-of node) "list") (= (type-of node) "list")
(for-each (fn (item) (scan-refs-walk item refs)) node) (for-each (fn (item) (scan-refs-walk item refs)) node)
;; Dict → recurse into values
(= (type-of node) "dict") (= (type-of node) "dict")
(for-each (fn (key) (scan-refs-walk (dict-get node key) refs)) (for-each
(keys node)) (fn (key) (scan-refs-walk (dict-get node key) refs))
(keys node))
;; Literals (number, string, boolean, nil, keyword) → no refs
:else nil))) :else nil)))
(define
;; -------------------------------------------------------------------------- transitive-deps-walk
;; 2. Transitive dependency closure :effects ()
;; -------------------------------------------------------------------------- (fn
;; Given a component name and an environment, compute all components ((n :as string) (seen :as list) (env :as dict))
;; that it can transitively render. Handles cycles via seen-set. (when
(not (contains? seen n))
(define transitive-deps-walk :effects []
(fn ((n :as string) (seen :as list) (env :as dict))
(when (not (contains? seen n))
(append! seen n) (append! seen n)
(let ((val (env-get env n))) (let
((val (env-get env n)))
(cond (cond
(or (= (type-of val) "component") (= (type-of val) "island")) (or (= (type-of val) "component") (= (type-of val) "island"))
(for-each (fn ((ref :as string)) (transitive-deps-walk ref seen env)) (for-each
(scan-refs (component-body val))) (fn ((ref :as string)) (transitive-deps-walk ref seen env))
(scan-refs (component-body val)))
(= (type-of val) "macro") (= (type-of val) "macro")
(for-each (fn ((ref :as string)) (transitive-deps-walk ref seen env)) (for-each
(scan-refs (macro-body val))) (fn ((ref :as string)) (transitive-deps-walk ref seen env))
(scan-refs (macro-body val)))
:else nil))))) :else nil)))))
(define
(define transitive-deps :effects [] transitive-deps
(fn ((name :as string) (env :as dict)) :effects ()
(let ((seen (list)) (fn
(key (if (starts-with? name "~") name (str "~" name)))) ((name :as string) (env :as dict))
(let
((seen (list))
(key (if (starts-with? name "~") name (str "~" name))))
(transitive-deps-walk key seen env) (transitive-deps-walk key seen env)
(filter (fn ((x :as string)) (not (= x key))) seen)))) (filter (fn ((x :as string)) (not (= x key))) seen))))
(define
;; -------------------------------------------------------------------------- compute-all-deps
;; 3. Compute deps for all components in an environment :effects (mutation)
;; -------------------------------------------------------------------------- (fn
;; Iterates env, calls transitive-deps for each component, and ((env :as dict))
;; stores the result via the platform's component-set-deps! function.
;;
;; Platform interface:
;; (env-components env) → list of component names in env
;; (component-set-deps! comp deps) → store deps on component
(define compute-all-deps :effects [mutation]
(fn ((env :as dict))
(for-each (for-each
(fn ((name :as string)) (fn
(let ((val (env-get env name))) ((name :as string))
(when (or (= (type-of val) "component") (= (type-of val) "island")) (let
((val (env-get env name)))
(when
(or (= (type-of val) "component") (= (type-of val) "island"))
(component-set-deps! val (transitive-deps name env))))) (component-set-deps! val (transitive-deps name env)))))
(env-components env)))) (env-components env))))
(define
;; -------------------------------------------------------------------------- scan-components-from-source
;; 4. Scan serialized SX source for component references :effects ()
;; -------------------------------------------------------------------------- (fn
;; Regex-based extraction of (~name patterns from SX wire format. ((source :as string))
;; Returns list of names WITH ~ prefix. (let
;; ((matches (regex-find-all "\\(~([a-zA-Z_][a-zA-Z0-9_\\-:/]*)" source)))
;; Platform interface:
;; (regex-find-all pattern source) → list of matched group strings
(define scan-components-from-source :effects []
(fn ((source :as string))
(let ((matches (regex-find-all "\\(~([a-zA-Z_][a-zA-Z0-9_\\-:/]*)" source)))
(map (fn ((m :as string)) (str "~" m)) matches)))) (map (fn ((m :as string)) (str "~" m)) matches))))
(define
;; -------------------------------------------------------------------------- components-needed
;; 5. Components needed for a page :effects ()
;; -------------------------------------------------------------------------- (fn
;; Scans page source for direct component references, then computes ((page-source :as string) (env :as dict))
;; the transitive closure. Returns list of ~names. (let
((direct (scan-components-from-source page-source))
(define components-needed :effects [] (all-needed (list)))
(fn ((page-source :as string) (env :as dict))
(let ((direct (scan-components-from-source page-source))
(all-needed (list)))
;; Add each direct ref + its transitive deps
(for-each (for-each
(fn ((name :as string)) (fn
(when (not (contains? all-needed name)) ((name :as string))
(append! all-needed name)) (when (not (contains? all-needed name)) (append! all-needed name))
(let ((val (env-get env name))) (let
(let ((deps (if (and (= (type-of val) "component") ((val (env-get env name)))
(not (empty? (component-deps val)))) (let
(component-deps val) ((deps (if (and (= (type-of val) "component") (not (empty? (component-deps val)))) (component-deps val) (transitive-deps name env))))
(transitive-deps name env))))
(for-each (for-each
(fn ((dep :as string)) (fn
(when (not (contains? all-needed dep)) ((dep :as string))
(when
(not (contains? all-needed dep))
(append! all-needed dep))) (append! all-needed dep)))
deps)))) deps))))
direct) direct)
all-needed))) all-needed)))
(define
;; -------------------------------------------------------------------------- page-component-bundle
;; 6. Build per-page component bundle :effects ()
;; -------------------------------------------------------------------------- (fn
;; Given page source and env, returns list of component names needed. ((page-source :as string) (env :as dict))
;; The host uses this list to serialize only the needed definitions
;; and compute a page-specific hash.
;;
;; This replaces the "send everything" approach with per-page bundles.
(define page-component-bundle :effects []
(fn ((page-source :as string) (env :as dict))
(components-needed page-source env))) (components-needed page-source env)))
(define
;; -------------------------------------------------------------------------- page-css-classes
;; 7. CSS classes for a page :effects ()
;; -------------------------------------------------------------------------- (fn
;; Returns the union of CSS classes from components this page uses, ((page-source :as string) (env :as dict))
;; plus classes from the page source itself. (let
;; ((needed (components-needed page-source env)) (classes (list)))
;; Platform interface:
;; (component-css-classes c) → set/list of class strings
;; (scan-css-classes source) → set/list of class strings from source
(define page-css-classes :effects []
(fn ((page-source :as string) (env :as dict))
(let ((needed (components-needed page-source env))
(classes (list)))
;; Collect classes from needed components
(for-each (for-each
(fn ((name :as string)) (fn
(let ((val (env-get env name))) ((name :as string))
(when (= (type-of val) "component") (let
((val (env-get env name)))
(when
(= (type-of val) "component")
(for-each (for-each
(fn ((cls :as string)) (fn
(when (not (contains? classes cls)) ((cls :as string))
(append! classes cls))) (when (not (contains? classes cls)) (append! classes cls)))
(component-css-classes val))))) (component-css-classes val)))))
needed) needed)
;; Add classes from page source
(for-each (for-each
(fn ((cls :as string)) (fn
(when (not (contains? classes cls)) ((cls :as string))
(append! classes cls))) (when (not (contains? classes cls)) (append! classes cls)))
(scan-css-classes page-source)) (scan-css-classes page-source))
classes))) classes)))
(define
;; -------------------------------------------------------------------------- scan-io-refs-walk
;; 8. IO detection — scan component ASTs for IO primitive references :effects ()
;; -------------------------------------------------------------------------- (fn
;; Extends the dependency walker to detect references to IO primitives. (node (io-names :as list) (refs :as list))
;; IO names are provided by the host (from boundary.sx declarations).
;; A component is "pure" if it (transitively) references no IO primitives.
;;
;; Platform interface additions:
;; (component-io-refs c) → cached IO ref list (may be empty)
;; (component-set-io-refs! c r) → cache IO refs on component
(define scan-io-refs-walk :effects []
(fn (node (io-names :as list) (refs :as list))
(cond (cond
;; Symbol → check if name is in the IO set
(= (type-of node) "symbol") (= (type-of node) "symbol")
(let ((name (symbol-name node))) (let
(when (contains? io-names name) ((name (symbol-name node)))
(when (not (contains? refs name)) (when
(append! refs name)))) (contains? io-names name)
(when (not (contains? refs name)) (append! refs name))))
;; List → recurse into all elements
(= (type-of node) "list") (= (type-of node) "list")
(for-each (fn (item) (scan-io-refs-walk item io-names refs)) node) (for-each (fn (item) (scan-io-refs-walk item io-names refs)) node)
;; Dict → recurse into values
(= (type-of node) "dict") (= (type-of node) "dict")
(for-each (fn (key) (scan-io-refs-walk (dict-get node key) io-names refs)) (for-each
(keys node)) (fn (key) (scan-io-refs-walk (dict-get node key) io-names refs))
(keys node))
;; Literals → no IO refs
:else nil))) :else nil)))
(define
scan-io-refs
:effects ()
(fn
(node (io-names :as list))
(let ((refs (list))) (scan-io-refs-walk node io-names refs) refs)))
(define scan-io-refs :effects [] (define
(fn (node (io-names :as list)) transitive-io-refs-walk
(let ((refs (list))) :effects ()
(scan-io-refs-walk node io-names refs) (fn
refs))) ((n :as string)
(seen :as list)
(all-refs :as list)
;; -------------------------------------------------------------------------- (env :as dict)
;; 9. Transitive IO refs — follow component deps and union IO refs (io-names :as list))
;; -------------------------------------------------------------------------- (when
(not (contains? seen n))
(define transitive-io-refs-walk :effects []
(fn ((n :as string) (seen :as list) (all-refs :as list) (env :as dict) (io-names :as list))
(when (not (contains? seen n))
(append! seen n) (append! seen n)
(let ((val (env-get env n))) (let
((val (env-get env n)))
(cond (cond
(= (type-of val) "component") (= (type-of val) "component")
(do (do
;; Scan this component's body for IO refs (for-each
(for-each (fn
(fn ((ref :as string)) ((ref :as string))
(when (not (contains? all-refs ref)) (when (not (contains? all-refs ref)) (append! all-refs ref)))
(append! all-refs ref))) (scan-io-refs (component-body val) io-names))
(scan-io-refs (component-body val) io-names)) (for-each
;; Recurse into component deps (fn
(for-each ((dep :as string))
(fn ((dep :as string)) (transitive-io-refs-walk dep seen all-refs env io-names)) (transitive-io-refs-walk dep seen all-refs env io-names))
(scan-refs (component-body val)))) (scan-refs (component-body val))))
(= (type-of val) "macro") (= (type-of val) "macro")
(do (do
(for-each (for-each
(fn ((ref :as string)) (fn
(when (not (contains? all-refs ref)) ((ref :as string))
(append! all-refs ref))) (when (not (contains? all-refs ref)) (append! all-refs ref)))
(scan-io-refs (macro-body val) io-names)) (scan-io-refs (macro-body val) io-names))
(for-each (for-each
(fn ((dep :as string)) (transitive-io-refs-walk dep seen all-refs env io-names)) (fn
(scan-refs (macro-body val)))) ((dep :as string))
(transitive-io-refs-walk dep seen all-refs env io-names))
(scan-refs (macro-body val))))
:else nil))))) :else nil)))))
(define
(define transitive-io-refs :effects [] transitive-io-refs
(fn ((name :as string) (env :as dict) (io-names :as list)) :effects ()
(let ((all-refs (list)) (fn
(seen (list)) ((name :as string) (env :as dict) (io-names :as list))
(key (if (starts-with? name "~") name (str "~" name)))) (let
((all-refs (list))
(seen (list))
(key (if (starts-with? name "~") name (str "~" name))))
(transitive-io-refs-walk key seen all-refs env io-names) (transitive-io-refs-walk key seen all-refs env io-names)
all-refs))) all-refs)))
(define
;; -------------------------------------------------------------------------- compute-all-io-refs
;; 10. Compute IO refs for all components in an environment :effects (mutation)
;; -------------------------------------------------------------------------- (fn
((env :as dict) (io-names :as list))
(define compute-all-io-refs :effects [mutation]
(fn ((env :as dict) (io-names :as list))
(for-each (for-each
(fn ((name :as string)) (fn
(let ((val (env-get env name))) ((name :as string))
(when (= (type-of val) "component") (let
(component-set-io-refs! val (transitive-io-refs name env io-names))))) ((val (env-get env name)))
(when
(= (type-of val) "component")
(component-set-io-refs!
val
(transitive-io-refs name env io-names)))))
(env-components env)))) (env-components env))))
(define
(define component-io-refs-cached :effects [] component-io-refs-cached
(fn ((name :as string) (env :as dict) (io-names :as list)) :effects ()
(let ((key (if (starts-with? name "~") name (str "~" name)))) (fn
(let ((val (env-get env key))) ((name :as string) (env :as dict) (io-names :as list))
(if (and (= (type-of val) "component") (let
(not (nil? (component-io-refs val))) ((key (if (starts-with? name "~") name (str "~" name))))
(not (empty? (component-io-refs val)))) (let
((val (env-get env key)))
(if
(and
(= (type-of val) "component")
(not (nil? (component-io-refs val)))
(not (empty? (component-io-refs val))))
(component-io-refs val) (component-io-refs val)
;; Fallback: not yet cached (shouldn't happen after compute-all-io-refs)
(transitive-io-refs name env io-names)))))) (transitive-io-refs name env io-names))))))
(define component-pure? :effects [] (define
(fn ((name :as string) (env :as dict) (io-names :as list)) component-pure?
(let ((key (if (starts-with? name "~") name (str "~" name)))) :effects ()
(let ((val (env-get env key))) (fn
(if (and (= (type-of val) "component") (name (env :as dict) (io-names :as list))
(not (nil? (component-io-refs val)))) (let
;; Use cached io-refs (empty list = pure) ((key (if (starts-with? name "~") name (str "~" name))))
(empty? (component-io-refs val)) (let
;; Fallback ((val (if (env-has? env key) (env-get env key) nil)))
(if
(and
(= (type-of val) "component")
(not (nil? (component-io-refs val)))
(not (empty? (component-io-refs val))))
false
(empty? (transitive-io-refs name env io-names))))))) (empty? (transitive-io-refs name env io-names)))))))
(define
;; -------------------------------------------------------------------------- render-target
;; 5. Render target — boundary decision per component :effects ()
;; -------------------------------------------------------------------------- (fn
;; Combines IO analysis with affinity annotations to decide where a (name (env :as dict) (io-names :as list))
;; component should render: (let
;; ((key (if (starts-with? name "~") name (str "~" name))))
;; :affinity :server → always "server" (auth-sensitive, secrets) (let
;; :affinity :client → "client" even if IO-dependent (IO proxy) ((val (if (env-has? env key) (env-get env key) nil)))
;; :affinity :auto → "server" if IO-dependent, "client" if pure (if
;; (not (= (type-of val) "component"))
;; Returns: "server" | "client"
(define render-target :effects []
(fn ((name :as string) (env :as dict) (io-names :as list))
(let ((key (if (starts-with? name "~") name (str "~" name))))
(let ((val (env-get env key)))
(if (not (= (type-of val) "component"))
"server" "server"
(let ((affinity (component-affinity val))) (let
((affinity (component-affinity val)))
(cond (cond
(= affinity "server") "server" (= affinity "server")
(= affinity "client") "client" "server"
;; auto: decide from IO analysis (= affinity "client")
(not (component-pure? name env io-names)) "server" "client"
(not (component-pure? name env io-names))
"server"
:else "client"))))))) :else "client")))))))
(define
;; -------------------------------------------------------------------------- page-render-plan
;; 6. Page render plan — pre-computed boundary decisions for a page :effects ()
;; -------------------------------------------------------------------------- (fn
;; Given page source + env + IO names, returns a render plan dict: ((page-source :as string) (env :as dict) (io-names :as list))
;; (let
;; {:components {~name "server"|"client" ...} ((needed (components-needed page-source env))
;; :server (list of ~names that render server-side) (comp-targets (dict))
;; :client (list of ~names that render client-side) (server-list (list))
;; :io-deps (list of IO primitives needed by server components)} (client-list (list))
;; (io-deps (list)))
;; This is computed once at page registration and cached on the page def.
;; The async evaluator and client router both use it to make decisions
;; without recomputing at every request.
(define page-render-plan :effects []
(fn ((page-source :as string) (env :as dict) (io-names :as list))
(let ((needed (components-needed page-source env))
(comp-targets (dict))
(server-list (list))
(client-list (list))
(io-deps (list)))
(for-each (for-each
(fn ((name :as string)) (fn
(let ((target (render-target name env io-names))) ((name :as string))
(let
((target (render-target name env io-names)))
(dict-set! comp-targets name target) (dict-set! comp-targets name target)
(if (= target "server") (if
(= target "server")
(do (do
(append! server-list name) (append! server-list name)
;; Collect IO deps from server components (use cache)
(for-each (for-each
(fn ((io-ref :as string)) (fn
(when (not (contains? io-deps io-ref)) ((io-ref :as string))
(when
(not (contains? io-deps io-ref))
(append! io-deps io-ref))) (append! io-deps io-ref)))
(component-io-refs-cached name env io-names))) (component-io-refs-cached name env io-names)))
(append! client-list name)))) (append! client-list name))))
needed) needed)
{:io-deps io-deps :server server-list :components comp-targets :client client-list})))
{:components comp-targets (define
:server server-list env-components
:client client-list :effects ()
:io-deps io-deps}))) (fn
((env :as dict))
;; --------------------------------------------------------------------------
;; Host obligation: selective expansion in async partial evaluation
;; --------------------------------------------------------------------------
;; The spec classifies components as pure or IO-dependent and provides
;; per-component render-target decisions. Each host's async partial
;; evaluator (the server-side rendering path that bridges sync evaluation
;; with async IO) must use this classification:
;;
;; render-target "server" → expand server-side (IO must resolve)
;; render-target "client" → serialize for client (can render anywhere)
;; Layout slot context → expand all (server needs full HTML)
;;
;; The spec provides: component-io-refs, component-pure?, render-target,
;; component-affinity. The host provides the async runtime that acts on it.
;; This is not SX semantics — it is host infrastructure. Every host
;; with a server-side async evaluator implements the same rule.
;; --------------------------------------------------------------------------
;; --------------------------------------------------------------------------
;; Platform interface summary
;; --------------------------------------------------------------------------
;;
;; From eval.sx (already provided):
;; (type-of x) → type string
;; (symbol-name s) → string name of symbol
;; (env-get env k) → value or nil
;;
;; New for deps.sx (each host implements):
;; (component-body c) → AST body of component
;; (component-name c) → name string
;; (component-deps c) → cached deps list (may be empty)
;; (component-set-deps! c d)→ cache deps on component
;; (component-css-classes c)→ pre-scanned CSS class list
;; (component-io-refs c) → cached IO ref list (may be empty)
;; (component-set-io-refs! c r)→ cache IO refs on component
;; (component-affinity c) → "auto" | "client" | "server"
;; (macro-body m) → AST body of macro
;; (regex-find-all pat src) → list of capture group matches
;; (scan-css-classes src) → list of CSS class strings from source
;; --------------------------------------------------------------------------
;; --------------------------------------------------------------------------
;; env-components — list component/macro names in an environment
;; --------------------------------------------------------------------------
;; Moved from platform to spec: pure logic using type predicates.
(define env-components :effects []
(fn ((env :as dict))
(filter (filter
(fn ((k :as string)) (fn
(let ((v (env-get env k))) ((k :as string))
(or (component? v) (macro? v)))) (let ((v (env-get env k))) (or (component? v) (macro? v))))
(keys env)))) (keys env))))

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

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