Add browser test integration and cell dependency tests · jon.recoil.org/js_top

+296

docs/test-gaps-design.md

··· 1 + # Test Gap Analysis and Design 2 + 3 + ## Current State 4 + 5 + ### Existing Infrastructure 6 + 7 + | Type | Location | Framework | Status | 8 + |------|----------|-----------|--------| 9 + | Node.js tests | `test/node/` | OCaml → js_of_ocaml → Node.js | ✅ Integrated in dune | 10 + | Cram tests | `test/cram/` | Shell + unix_worker/client | ✅ Integrated in dune | 11 + | Unit tests | `test/libtest/` | ppx_expect | ✅ Integrated in dune | 12 + | Browser tests | `test/browser/` | Playwright | ❌ **Not integrated** | 13 + 14 + ### Browser Test Files (exist but not wired up) 15 + 16 + ``` 17 + test/browser/ 18 + ├── package.json # Playwright dependency 19 + ├── run_tests.js # Playwright runner (serves files, runs browser) 20 + ├── test.html # Test harness HTML 21 + ├── client_test.ml # OCaml test code (needs compilation) 22 + ├── test_worker.ml # Test worker (needs compilation) 23 + ├── test_features.js # Feature tests (MIME, autocomplete, etc.) 24 + ├── test_env_isolation.js # Environment isolation test 25 + └── test_demo.js # Demo page test 26 + ``` 27 + 28 + ## Critical Gaps 29 + 30 + ### 1. Cell Dependencies 31 + 32 + **Current coverage:** Linear chain only (`c1 → c2 → c3 → c4`) 33 + 34 + **Missing scenarios:** 35 + 36 + ``` 37 + A. Diamond dependency: 38 + c1 (type t = int) 39 + ↓ ↓ 40 + c2 (x:t) c3 (y:t) 41 + ↓ ↓ 42 + c4 (x + y) 43 + 44 + B. Missing dependency: 45 + c2 depends on ["c1"] but c1 doesn't exist → should error gracefully 46 + 47 + C. Circular reference handling: 48 + c1 depends on ["c2"], c2 depends on ["c1"] → should detect/reject 49 + 50 + D. Dependency update propagation: 51 + c1 changes → c2, c3 that depend on c1 should see new types 52 + 53 + E. Type shadowing across cells: 54 + c1: type t = int 55 + c2: type t = string (depends on c1) 56 + c3: uses t (depends on c1, c2) → which t? 57 + ``` 58 + 59 + ### 2. Error Recovery 60 + 61 + **Missing scenarios:** 62 + 63 + ``` 64 + A. Syntax errors: 65 + - Unterminated string/comment 66 + - Mismatched brackets 67 + - Invalid tokens 68 + 69 + B. Type errors with recovery: 70 + - First phrase errors, second should still work 71 + - Error in middle of multi-phrase input 72 + 73 + C. Runtime errors: 74 + - Stack overflow (deep recursion) 75 + - Out of memory (large data structures) 76 + - Division by zero 77 + 78 + D. Toplevel state corruption: 79 + - Can we continue after an error? 80 + - Is state consistent after partial execution? 81 + ``` 82 + 83 + ### 3. Browser/WebWorker Integration 84 + 85 + **Problem:** Tests exist but aren't run by `dune runtest` 86 + 87 + **Current workflow (manual):** 88 + ```bash 89 + cd test/browser 90 + npm install 91 + # Manually build OCaml files somehow 92 + npm test 93 + ``` 94 + 95 + **Needed workflow:** 96 + ```bash 97 + dune runtest # Should include browser tests 98 + ``` 99 + 100 + ## Proposed Design 101 + 102 + ### Browser Test Integration 103 + 104 + #### Option A: Playwright in dune (Recommended) 105 + 106 + ``` 107 + test/browser/dune: 108 + ───────────────────── 109 + (executable 110 + (name client_test) 111 + (modes js) 112 + (libraries js_top_worker-client lwt js_of_ocaml)) 113 + 114 + (executable 115 + (name test_worker) 116 + (modes js) 117 + (libraries js_top_worker-web ...)) 118 + 119 + (rule 120 + (alias runtest) 121 + (deps 122 + client_test.bc.js 123 + test_worker.bc.js 124 + test.html 125 + (:runner run_tests.js)) 126 + (action 127 + (run node %{runner}))) 128 + ``` 129 + 130 + **Pros:** 131 + - Integrated into normal `dune runtest` 132 + - OCaml files compiled automatically 133 + - Playwright handles browser lifecycle 134 + 135 + **Cons:** 136 + - Requires Node.js + Playwright installed 137 + - Slower than headless Node tests 138 + 139 + #### Option B: Separate browser test target 140 + 141 + ```bash 142 + dune runtest # Node + cram tests only 143 + dune runtest @browser # Browser tests (when Playwright available) 144 + ``` 145 + 146 + **Pros:** 147 + - CI can skip browser tests if Playwright not available 148 + - Faster default test runs 149 + 150 + **Cons:** 151 + - Easy to forget to run browser tests 152 + 153 + #### Recommendation: Option B with CI integration 154 + 155 + - Default `dune runtest` excludes browser tests 156 + - `dune runtest @browser` for browser tests 157 + - CI runs both 158 + 159 + ### Cell Dependency Tests 160 + 161 + Add to `test/node/node_dependency_test.ml`: 162 + 163 + ```ocaml 164 + (* Test diamond dependencies *) 165 + let test_diamond rpc = 166 + (* c1: base type *) 167 + let* _ = query_errors rpc "" (Some "c1") [] false "type point = {x:int; y:int};;" in 168 + 169 + (* c2, c3: both depend on c1 *) 170 + let* _ = query_errors rpc "" (Some "c2") ["c1"] false "let origin : point = {x=0;y=0};;" in 171 + let* _ = query_errors rpc "" (Some "c3") ["c1"] false "let unit_x : point = {x=1;y=0};;" in 172 + 173 + (* c4: depends on c2 and c3 *) 174 + let* errors = query_errors rpc "" (Some "c4") ["c2";"c3"] false 175 + "let add p1 p2 = {x=p1.x+p2.x; y=p1.y+p2.y};; add origin unit_x;;" in 176 + 177 + assert (List.length errors = 0); 178 + Lwt.return (Ok ()) 179 + 180 + (* Test missing dependency *) 181 + let test_missing_dep rpc = 182 + let* errors = query_errors rpc "" (Some "c2") ["nonexistent"] false "let x = 1;;" in 183 + (* Should either error or work without the dep *) 184 + ... 185 + 186 + (* Test dependency update *) 187 + let test_dep_update rpc = 188 + let* _ = query_errors rpc "" (Some "c1") [] false "type t = int;;" in 189 + let* _ = query_errors rpc "" (Some "c2") ["c1"] false "let x : t = 42;;" in 190 + 191 + (* Update c1 *) 192 + let* _ = query_errors rpc "" (Some "c1") [] false "type t = string;;" in 193 + 194 + (* c2 should now have error (42 is not string) *) 195 + let* errors = query_errors rpc "" (Some "c2") ["c1"] false "let x : t = 42;;" in 196 + assert (List.length errors > 0); 197 + Lwt.return (Ok ()) 198 + ``` 199 + 200 + ### Error Recovery Tests 201 + 202 + Add to `test/node/node_error_test.ml`: 203 + 204 + ```ocaml 205 + (* Test recovery after syntax error *) 206 + let test_syntax_recovery rpc = 207 + (* First phrase has error *) 208 + let* _ = exec rpc "" "let x = ;;" in (* syntax error *) 209 + 210 + (* Second phrase should still work *) 211 + let* result = exec rpc "" "let y = 42;;" in 212 + assert (result.caml_ppf |> Option.is_some); 213 + Lwt.return (Ok ()) 214 + 215 + (* Test partial execution *) 216 + let test_partial_exec rpc = 217 + (* Multi-phrase where second fails *) 218 + let* result = exec rpc "" "let a = 1;; let b : string = a;; let c = 3;;" in 219 + (* a should be defined, b should error, c may or may not run *) 220 + ... 221 + ``` 222 + 223 + ### Findlib Tests 224 + 225 + Add more packages to cram tests: 226 + 227 + ``` 228 + test/cram/findlib.t/run.t: 229 + ────────────────────────── 230 + # Test loading multiple packages with dependencies 231 + $ unix_client exec_toplevel '' '#require "lwt";; #require "lwt.unix";;' 232 + $ unix_client exec_toplevel '' 'Lwt_main.run (Lwt.return 42);;' 233 + 234 + # Test package with PPX 235 + $ unix_client exec_toplevel '' '#require "ppx_deriving.show";;' 236 + $ unix_client exec_toplevel '' 'type t = A | B [@@deriving show];; show_t A;;' 237 + 238 + # Test package not found 239 + $ unix_client exec_toplevel '' '#require "nonexistent_package_12345";;' 240 + ``` 241 + 242 + ## Implementation Plan 243 + 244 + ### Phase 1: Browser Test Integration ✅ COMPLETED 245 + 246 + 1. ✅ Added `test/browser/dune` to compile OCaml test files 247 + 2. ✅ Added `@browser` and `@runbrowser` aliases for Playwright tests 248 + 3. ✅ Fixed test_worker.ml to include `js_of_ocaml-toplevel` library 249 + 4. ✅ All browser tests pass (6/6) 250 + 251 + **Key fix:** The test worker needed `js_of_ocaml-toplevel` in libraries to properly 252 + initialize the OCaml toplevel for code compilation. 253 + 254 + ### Phase 2: Cell Dependency Tests ✅ COMPLETED 255 + 256 + 1. ✅ Created `test/node/node_dependency_test.ml` 257 + 2. ✅ Added tests for: 258 + - Linear dependencies (c1 → c2 → c3 → c4) 259 + - Diamond dependencies (d1 → d2,d3 → d4) 260 + - Missing dependencies (errors properly when referencing non-existent cells) 261 + - Dependency update propagation (type changes in d1 affect d2) 262 + - Type shadowing across cells 263 + - Complex dependency graphs with modules 264 + 3. ✅ Added to dune build with expected output 265 + 266 + **Key finding:** Dependencies are NOT transitive. If cell d4 needs types from d1 267 + through d2/d3, it must explicitly list d1 in its dependency array. 268 + 269 + All 26 dependency tests pass. 270 + 271 + ### Phase 3: Error Recovery Tests (pending) 272 + 273 + 1. Create `test/node/node_error_test.ml` 274 + 2. Test syntax errors, type errors, runtime errors 275 + 3. Test state consistency after errors 276 + 277 + ### Phase 4: Expanded Findlib Tests (pending) 278 + 279 + 1. Add `test/cram/findlib.t/` 280 + 2. Test more packages (lwt, ppx_deriving, etc.) 281 + 3. Test error cases 282 + 283 + ## Decisions 284 + 285 + 1. **Browser test alias:** Separate `@browser` alias (not in default `runtest`) 286 + 287 + 2. **Browsers:** Chrome only for now 288 + 289 + 3. **Cell dependency semantics:** 290 + - Circular deps → Error (unbound module) 291 + - Missing deps → Error (unbound module) 292 + - Dependencies are explicit, not transitive 293 + 294 + 4. **Error recovery:** TBD - needs investigation 295 + 296 + 5. **CI:** Browser tests advisory-only initially

+41

test/browser/dune

··· 1 + ; Browser tests using Playwright 2 + ; Run with: dune build @browser 3 + 4 + (executable 5 + (name client_test) 6 + (modes js) 7 + (modules client_test) 8 + (preprocess (pps js_of_ocaml-ppx)) 9 + (libraries js_top_worker-client js_top_worker-rpc astring lwt js_of_ocaml)) 10 + 11 + (executable 12 + (name test_worker) 13 + (modes js) 14 + (modules test_worker) 15 + (link_flags (-linkall)) 16 + (preprocess (pps js_of_ocaml-ppx)) 17 + (js_of_ocaml 18 + (javascript_files ../../lib/stubs.js) 19 + (flags --effects=disabled --toplevel +toplevel.js +dynlink.js)) 20 + (libraries js_top_worker js_top_worker-rpc js_of_ocaml js_of_ocaml-toplevel lwt)) 21 + 22 + ; Browser test alias - runs Playwright 23 + ; Requires: cd test/browser && npm install (once) 24 + (alias 25 + (name browser) 26 + (deps 27 + client_test.bc.js 28 + test_worker.bc.js 29 + (source_tree .))) 30 + 31 + (rule 32 + (alias runbrowser) 33 + (deps 34 + client_test.bc.js 35 + test_worker.bc.js 36 + (source_tree .)) 37 + (action 38 + (chdir %{project_root}/test/browser 39 + (progn 40 + (echo "Running browser tests with Playwright...\n") 41 + (run node run_tests.js)))))

+5 -2

test/browser/test_worker.ml

··· 44 44 let open Js_of_ocaml in 45 45 let open M in 46 46 Console.console##log (Js.string "Test worker starting..."); 47 - Server.exec execute; 47 + Server.init (Impl.IdlM.T.lift init); 48 + Server.create_env (Impl.IdlM.T.lift create_env); 49 + Server.destroy_env (Impl.IdlM.T.lift destroy_env); 50 + Server.list_envs (Impl.IdlM.T.lift list_envs); 48 51 Server.setup (Impl.IdlM.T.lift setup); 49 - Server.init (Impl.IdlM.T.lift init); 52 + Server.exec execute; 50 53 Server.complete_prefix complete_prefix; 51 54 Server.query_errors query_errors; 52 55 Server.type_enclosing type_enclosing;

+59

test/node/dune

··· 297 297 (deps _opam) 298 298 (action 299 299 (diff node_mime_test.expected node_mime_test.out))) 300 + 301 + ; Cell dependency test executable 302 + (executable 303 + (name node_dependency_test) 304 + (modes byte) 305 + (modules node_dependency_test) 306 + (link_flags (-linkall)) 307 + (libraries 308 + str 309 + fpath 310 + js_of_ocaml 311 + js_top_worker-web 312 + js_of_ocaml-toplevel 313 + js_top_worker 314 + logs 315 + logs.fmt 316 + rpclib.core 317 + rpclib.json 318 + findlib.top 319 + js_of_ocaml-lwt 320 + zarith_stubs_js)) 321 + 322 + (rule 323 + (targets node_dependency_test.js) 324 + (action 325 + (run 326 + %{bin:js_of_ocaml} 327 + --toplevel 328 + --pretty 329 + --no-cmis 330 + --effects=cps 331 + --debuginfo 332 + --target-env=nodejs 333 + +toplevel.js 334 + +dynlink.js 335 + +bigstringaf/runtime.js 336 + +zarith_stubs_js/runtime.js 337 + %{lib:js_top_worker:stubs.js} 338 + %{dep:node_dependency_test.bc} 339 + -o 340 + %{targets}))) 341 + 342 + (rule 343 + (deps _opam) 344 + (action 345 + (with-outputs-to 346 + node_dependency_test.out 347 + (run 348 + node 349 + --stack-size=2000 350 + -r 351 + ./%{dep:import_scripts.js} 352 + %{dep:node_dependency_test.js})))) 353 + 354 + (rule 355 + (alias runtest) 356 + (deps _opam) 357 + (action 358 + (diff node_dependency_test.expected node_dependency_test.out)))

+193

test/node/node_dependency_test.expected

··· 1 + === Node.js Cell Dependency Tests === 2 + 3 + Initializing findlib 4 + Loaded findlib_index findlib_index: 10 META files, 0 universes 5 + Parsed uri: ./lib/stdlib-shims/META 6 + Reading library: stdlib-shims 7 + Number of children: 0 8 + Parsed uri: ./lib/sexplib0/META 9 + Reading library: sexplib0 10 + Number of children: 0 11 + Parsed uri: ./lib/ppxlib/META 12 + Reading library: ppxlib 13 + Number of children: 11 14 + Found child: __private__ 15 + Reading library: ppxlib.__private__ 16 + Number of children: 1 17 + Found child: ppx_foo_deriver 18 + Reading library: ppxlib.__private__.ppx_foo_deriver 19 + Number of children: 0 20 + Found child: ast 21 + Reading library: ppxlib.ast 22 + Number of children: 0 23 + Found child: astlib 24 + Reading library: ppxlib.astlib 25 + Number of children: 0 26 + Found child: metaquot 27 + Reading library: ppxlib.metaquot 28 + Number of children: 0 29 + Found child: metaquot_lifters 30 + Reading library: ppxlib.metaquot_lifters 31 + Number of children: 0 32 + Found child: print_diff 33 + Reading library: ppxlib.print_diff 34 + Number of children: 0 35 + Found child: runner 36 + Reading library: ppxlib.runner 37 + Number of children: 0 38 + Found child: runner_as_ppx 39 + Reading library: ppxlib.runner_as_ppx 40 + Number of children: 0 41 + Found child: stdppx 42 + Reading library: ppxlib.stdppx 43 + Number of children: 0 44 + Found child: traverse 45 + Reading library: ppxlib.traverse 46 + Number of children: 0 47 + Found child: traverse_builtins 48 + Reading library: ppxlib.traverse_builtins 49 + Number of children: 0 50 + Parsed uri: ./lib/ppx_deriving/META 51 + Reading library: ppx_deriving 52 + Number of children: 12 53 + Found child: api 54 + Reading library: ppx_deriving.api 55 + Number of children: 0 56 + Found child: create 57 + Reading library: ppx_deriving.create 58 + Number of children: 0 59 + Found child: enum 60 + Reading library: ppx_deriving.enum 61 + Number of children: 0 62 + Found child: eq 63 + Reading library: ppx_deriving.eq 64 + Number of children: 0 65 + Found child: fold 66 + Reading library: ppx_deriving.fold 67 + Number of children: 0 68 + Found child: iter 69 + Reading library: ppx_deriving.iter 70 + Number of children: 0 71 + Found child: make 72 + Reading library: ppx_deriving.make 73 + Number of children: 0 74 + Found child: map 75 + Reading library: ppx_deriving.map 76 + Number of children: 0 77 + Found child: ord 78 + Reading library: ppx_deriving.ord 79 + Number of children: 0 80 + Found child: runtime 81 + Reading library: ppx_deriving.runtime 82 + Number of children: 0 83 + Found child: show 84 + Reading library: ppx_deriving.show 85 + Number of children: 0 86 + Found child: std 87 + Reading library: ppx_deriving.std 88 + Number of children: 0 89 + Parsed uri: ./lib/ppx_derivers/META 90 + Reading library: ppx_derivers 91 + Number of children: 0 92 + Parsed uri: ./lib/ocaml_intrinsics_kernel/META 93 + Reading library: ocaml_intrinsics_kernel 94 + Number of children: 0 95 + Parsed uri: ./lib/ocaml/stdlib/META 96 + Reading library: stdlib 97 + Number of children: 0 98 + Parsed uri: ./lib/ocaml/compiler-libs/META 99 + Reading library: compiler-libs 100 + Number of children: 5 101 + Found child: common 102 + Reading library: compiler-libs.common 103 + Number of children: 0 104 + Found child: bytecomp 105 + Reading library: compiler-libs.bytecomp 106 + Number of children: 0 107 + Found child: optcomp 108 + Reading library: compiler-libs.optcomp 109 + Number of children: 0 110 + Found child: toplevel 111 + Reading library: compiler-libs.toplevel 112 + Number of children: 0 113 + Found child: native-toplevel 114 + Reading library: compiler-libs.native-toplevel 115 + Number of children: 0 116 + Parsed uri: ./lib/ocaml-compiler-libs/META 117 + Reading library: ocaml-compiler-libs 118 + Number of children: 5 119 + Found child: bytecomp 120 + Reading library: ocaml-compiler-libs.bytecomp 121 + Number of children: 0 122 + Found child: common 123 + Reading library: ocaml-compiler-libs.common 124 + Number of children: 0 125 + Found child: optcomp 126 + Reading library: ocaml-compiler-libs.optcomp 127 + Number of children: 0 128 + Found child: shadow 129 + Reading library: ocaml-compiler-libs.shadow 130 + Number of children: 0 131 + Found child: toplevel 132 + Reading library: ocaml-compiler-libs.toplevel 133 + Number of children: 0 134 + Parsed uri: ./lib/base/META 135 + Reading library: base 136 + Number of children: 3 137 + Found child: base_internalhash_types 138 + Reading library: base.base_internalhash_types 139 + Number of children: 0 140 + Found child: md5 141 + Reading library: base.md5 142 + Number of children: 0 143 + Found child: shadow_stdlib 144 + Reading library: base.shadow_stdlib 145 + Number of children: 0 146 + error while evaluating #enable "pretty";; 147 + error while evaluating #disable "shortvar";; 148 + [PASS] init: Initialized and setup 149 + 150 + --- Section 1: Linear Dependencies --- 151 + [PASS] linear_c1: 0 errors 152 + [PASS] linear_c2: 0 errors 153 + [PASS] linear_c3: 0 errors 154 + [PASS] linear_c4: 0 errors 155 + 156 + --- Section 2: Diamond Dependencies --- 157 + [PASS] diamond_d1: 0 errors 158 + [PASS] diamond_d2: 0 errors 159 + [PASS] diamond_d3: 0 errors 160 + [PASS] diamond_d4: 0 errors 161 + 162 + --- Section 3: Missing Dependencies --- 163 + [PASS] missing_dep_error: 2 errors (expected > 0) 164 + node_dependency_test.js: [ERROR] Env.Error: File "_none_", line 1: 165 + Error: Unbound module Cell__nonexistent 166 + 167 + [PASS] missing_dep_simple_ok: 0 errors 168 + 169 + --- Section 4: Dependency Update Propagation --- 170 + [PASS] update_u1_initial: 0 errors 171 + [PASS] update_u2_initial: 0 errors 172 + [PASS] update_u1_changed: 0 errors 173 + [PASS] update_u2_error: 1 errors (expected > 0) 174 + [PASS] update_u2_fixed: 0 errors 175 + 176 + --- Section 5: Type Shadowing --- 177 + [PASS] shadow_s1: 0 errors 178 + [PASS] shadow_s2: 0 errors 179 + [PASS] shadow_s3_string: 0 errors 180 + [PASS] shadow_s4_int: 0 errors 181 + 182 + --- Section 6: Complex Dependency Graph --- 183 + [PASS] graph_g1: 0 errors 184 + [PASS] graph_g2: 0 errors 185 + [PASS] graph_g3: 0 errors 186 + [PASS] graph_g4: 0 errors 187 + 188 + --- Section 7: Empty and Self Dependencies --- 189 + [PASS] empty_deps: 0 errors 190 + [PASS] self_define: 0 errors 191 + 192 + === Results: 26/26 tests passed === 193 + SUCCESS: All dependency tests passed!

+328

test/node/node_dependency_test.ml

··· 1 + (** Node.js test for cell dependency system. 2 + 3 + This tests that cell dependencies work correctly, including: 4 + - Linear dependencies (c1 → c2 → c3) 5 + - Diamond dependencies (c1 → c2, c3 → c4) 6 + - Missing dependencies (referencing non-existent cell) 7 + - Dependency update propagation 8 + - Type shadowing across cells 9 + *) 10 + 11 + open Js_top_worker 12 + open Js_top_worker_rpc.Toplevel_api_gen 13 + open Impl 14 + 15 + (* Flusher that writes to process.stdout in Node.js *) 16 + let console_flusher (s : string) : unit = 17 + let open Js_of_ocaml in 18 + let process = Js.Unsafe.get Js.Unsafe.global (Js.string "process") in 19 + let stdout = Js.Unsafe.get process (Js.string "stdout") in 20 + let write = Js.Unsafe.get stdout (Js.string "write") in 21 + ignore (Js.Unsafe.call write stdout [| Js.Unsafe.inject (Js.string s) |]) 22 + 23 + let capture : (unit -> 'a) -> unit -> Impl.captured * 'a = 24 + fun f () -> 25 + let stdout_buff = Buffer.create 1024 in 26 + let stderr_buff = Buffer.create 1024 in 27 + Js_of_ocaml.Sys_js.set_channel_flusher stdout (Buffer.add_string stdout_buff); 28 + let x = f () in 29 + let captured = 30 + { 31 + Impl.stdout = Buffer.contents stdout_buff; 32 + stderr = Buffer.contents stderr_buff; 33 + } 34 + in 35 + Js_of_ocaml.Sys_js.set_channel_flusher stdout console_flusher; 36 + (captured, x) 37 + 38 + module Server = Js_top_worker_rpc.Toplevel_api_gen.Make (Impl.IdlM.GenServer ()) 39 + 40 + module S : Impl.S = struct 41 + type findlib_t = Js_top_worker_web.Findlibish.t 42 + 43 + let capture = capture 44 + 45 + let sync_get f = 46 + let f = Fpath.v ("_opam/" ^ f) in 47 + try Some (In_channel.with_open_bin (Fpath.to_string f) In_channel.input_all) 48 + with _ -> None 49 + 50 + let async_get f = 51 + let f = Fpath.v ("_opam/" ^ f) in 52 + try 53 + let content = 54 + In_channel.with_open_bin (Fpath.to_string f) In_channel.input_all 55 + in 56 + Lwt.return (Ok content) 57 + with e -> Lwt.return (Error (`Msg (Printexc.to_string e))) 58 + 59 + let create_file = Js_of_ocaml.Sys_js.create_file 60 + 61 + let import_scripts urls = 62 + let open Js_of_ocaml.Js in 63 + let import_scripts_fn = Unsafe.get Unsafe.global (string "importScripts") in 64 + List.iter 65 + (fun url -> 66 + let (_ : 'a) = 67 + Unsafe.fun_call import_scripts_fn [| Unsafe.inject (string url) |] 68 + in 69 + ()) 70 + urls 71 + 72 + let init_function _ () = failwith "Not implemented" 73 + let findlib_init = Js_top_worker_web.Findlibish.init async_get 74 + 75 + let get_stdlib_dcs uri = 76 + Js_top_worker_web.Findlibish.fetch_dynamic_cmis sync_get uri 77 + |> Result.to_list 78 + 79 + let require b v = function 80 + | [] -> [] 81 + | packages -> 82 + Js_top_worker_web.Findlibish.require ~import_scripts sync_get b v 83 + packages 84 + 85 + let path = "/static/cmis" 86 + end 87 + 88 + module U = Impl.Make (S) 89 + 90 + let start_server () = 91 + let open U in 92 + Logs.set_reporter (Logs_fmt.reporter ()); 93 + Logs.set_level (Some Logs.Warning); 94 + Server.init (IdlM.T.lift init); 95 + Server.create_env (IdlM.T.lift create_env); 96 + Server.destroy_env (IdlM.T.lift destroy_env); 97 + Server.list_envs (IdlM.T.lift list_envs); 98 + Server.setup (IdlM.T.lift setup); 99 + Server.exec execute; 100 + Server.complete_prefix complete_prefix; 101 + Server.query_errors query_errors; 102 + Server.type_enclosing type_enclosing; 103 + Server.exec_toplevel exec_toplevel; 104 + IdlM.server Server.implementation 105 + 106 + module Client = Js_top_worker_rpc.Toplevel_api_gen.Make (Impl.IdlM.GenClient ()) 107 + 108 + (* Test result tracking *) 109 + let total_tests = ref 0 110 + let passed_tests = ref 0 111 + 112 + let test name check message = 113 + incr total_tests; 114 + let passed = check in 115 + if passed then incr passed_tests; 116 + let status = if passed then "PASS" else "FAIL" in 117 + Printf.printf "[%s] %s: %s\n%!" status name message 118 + 119 + let query_errors rpc env_id cell_id deps source = 120 + Client.query_errors rpc env_id cell_id deps false source 121 + 122 + let _ = 123 + Printf.printf "=== Node.js Cell Dependency Tests ===\n\n%!"; 124 + 125 + let rpc = start_server () in 126 + let ( let* ) = IdlM.ErrM.bind in 127 + 128 + let init_config = 129 + { stdlib_dcs = None; findlib_requires = []; findlib_index = None; execute = true } 130 + in 131 + 132 + let test_sequence = 133 + (* Initialize and setup *) 134 + let* _ = Client.init rpc init_config in 135 + let* _ = Client.setup rpc "" in 136 + test "init" true "Initialized and setup"; 137 + 138 + Printf.printf "\n--- Section 1: Linear Dependencies ---\n%!"; 139 + 140 + (* c1: base definition *) 141 + let* errors = query_errors rpc "" (Some "c1") [] "type t = int;;" in 142 + test "linear_c1" (List.length errors = 0) 143 + (Printf.sprintf "%d errors" (List.length errors)); 144 + 145 + (* c2 depends on c1 *) 146 + let* errors = query_errors rpc "" (Some "c2") ["c1"] "let x : t = 42;;" in 147 + test "linear_c2" (List.length errors = 0) 148 + (Printf.sprintf "%d errors" (List.length errors)); 149 + 150 + (* c3 depends on c2 (and transitively c1) *) 151 + let* errors = query_errors rpc "" (Some "c3") ["c2"] "let y = x + 1;;" in 152 + test "linear_c3" (List.length errors = 0) 153 + (Printf.sprintf "%d errors" (List.length errors)); 154 + 155 + (* c4 depends on c3 *) 156 + let* errors = query_errors rpc "" (Some "c4") ["c3"] "let z = y * 2;;" in 157 + test "linear_c4" (List.length errors = 0) 158 + (Printf.sprintf "%d errors" (List.length errors)); 159 + 160 + Printf.printf "\n--- Section 2: Diamond Dependencies ---\n%!"; 161 + 162 + (* d1: base type *) 163 + let* errors = query_errors rpc "" (Some "d1") [] 164 + "type point = { x: int; y: int };;" in 165 + test "diamond_d1" (List.length errors = 0) 166 + (Printf.sprintf "%d errors" (List.length errors)); 167 + 168 + (* d2 depends on d1 *) 169 + let* errors = query_errors rpc "" (Some "d2") ["d1"] 170 + "let origin : point = { x = 0; y = 0 };;" in 171 + test "diamond_d2" (List.length errors = 0) 172 + (Printf.sprintf "%d errors" (List.length errors)); 173 + 174 + (* d3 depends on d1 (parallel to d2) *) 175 + let* errors = query_errors rpc "" (Some "d3") ["d1"] 176 + "let unit_x : point = { x = 1; y = 0 };;" in 177 + test "diamond_d3" (List.length errors = 0) 178 + (Printf.sprintf "%d errors" (List.length errors)); 179 + 180 + (* d4 depends on d2, d3, and transitively needs d1 for the point type *) 181 + let* errors = query_errors rpc "" (Some "d4") ["d1"; "d2"; "d3"] 182 + "let add p1 p2 : point = { x = p1.x + p2.x; y = p1.y + p2.y };;\n\ 183 + let result = add origin unit_x;;" in 184 + test "diamond_d4" (List.length errors = 0) 185 + (Printf.sprintf "%d errors" (List.length errors)); 186 + 187 + Printf.printf "\n--- Section 3: Missing Dependencies ---\n%!"; 188 + 189 + (* Try to use a type from a cell that doesn't exist in deps *) 190 + let* errors = query_errors rpc "" (Some "m1") [] 191 + "let bad : point = { x = 1; y = 2 };;" in 192 + test "missing_dep_error" (List.length errors > 0) 193 + (Printf.sprintf "%d errors (expected > 0)" (List.length errors)); 194 + 195 + (* Reference with missing dependency - should fail *) 196 + let* errors = query_errors rpc "" (Some "m2") ["nonexistent"] 197 + "let a = 1;;" in 198 + (* Even with a missing dep in the list, simple code should work *) 199 + test "missing_dep_simple_ok" (List.length errors = 0) 200 + (Printf.sprintf "%d errors" (List.length errors)); 201 + 202 + Printf.printf "\n--- Section 4: Dependency Update Propagation ---\n%!"; 203 + 204 + (* u1: initial type *) 205 + let* errors = query_errors rpc "" (Some "u1") [] "type u = int;;" in 206 + test "update_u1_initial" (List.length errors = 0) 207 + (Printf.sprintf "%d errors" (List.length errors)); 208 + 209 + (* u2: depends on u1, uses type u as int *) 210 + let* errors = query_errors rpc "" (Some "u2") ["u1"] "let val_u : u = 42;;" in 211 + test "update_u2_initial" (List.length errors = 0) 212 + (Printf.sprintf "%d errors" (List.length errors)); 213 + 214 + (* Now update u1 to change type u to string *) 215 + let* errors = query_errors rpc "" (Some "u1") [] "type u = string;;" in 216 + test "update_u1_changed" (List.length errors = 0) 217 + (Printf.sprintf "%d errors" (List.length errors)); 218 + 219 + (* u2 with same code should now error (42 is not string) *) 220 + let* errors = query_errors rpc "" (Some "u2") ["u1"] "let val_u : u = 42;;" in 221 + test "update_u2_error" (List.length errors > 0) 222 + (Printf.sprintf "%d errors (expected > 0)" (List.length errors)); 223 + 224 + (* Fix u2 to work with string type *) 225 + let* errors = query_errors rpc "" (Some "u2") ["u1"] 226 + "let val_u : u = \"hello\";;" in 227 + test "update_u2_fixed" (List.length errors = 0) 228 + (Printf.sprintf "%d errors" (List.length errors)); 229 + 230 + Printf.printf "\n--- Section 5: Type Shadowing ---\n%!"; 231 + 232 + (* s1: defines type t = int *) 233 + let* errors = query_errors rpc "" (Some "s1") [] "type t = int;;" in 234 + test "shadow_s1" (List.length errors = 0) 235 + (Printf.sprintf "%d errors" (List.length errors)); 236 + 237 + (* s2: depends on s1, also defines type t = string (shadows) *) 238 + let* errors = query_errors rpc "" (Some "s2") ["s1"] 239 + "type t = string;;" in 240 + test "shadow_s2" (List.length errors = 0) 241 + (Printf.sprintf "%d errors" (List.length errors)); 242 + 243 + (* s3: depends on s2 - should see t as string, not int *) 244 + let* errors = query_errors rpc "" (Some "s3") ["s2"] 245 + "let shadowed : t = \"works\";;" in 246 + test "shadow_s3_string" (List.length errors = 0) 247 + (Printf.sprintf "%d errors" (List.length errors)); 248 + 249 + (* s4: depends only on s1 - should see t as int *) 250 + let* errors = query_errors rpc "" (Some "s4") ["s1"] 251 + "let original : t = 123;;" in 252 + test "shadow_s4_int" (List.length errors = 0) 253 + (Printf.sprintf "%d errors" (List.length errors)); 254 + 255 + Printf.printf "\n--- Section 6: Complex Dependency Graph ---\n%!"; 256 + 257 + (* 258 + g1 ─┬─→ g2 ───→ g4 259 + │ │ 260 + └─→ g3 ─────┘ 261 + 262 + g1 defines base 263 + g2 and g3 both depend on g1 264 + g4 depends on g2 and g3 265 + *) 266 + 267 + let* errors = query_errors rpc "" (Some "g1") [] 268 + "module Base = struct\n\ 269 + \ type id = int\n\ 270 + \ let make_id x = x\n\ 271 + end;;" in 272 + test "graph_g1" (List.length errors = 0) 273 + (Printf.sprintf "%d errors" (List.length errors)); 274 + 275 + let* errors = query_errors rpc "" (Some "g2") ["g1"] 276 + "module User = struct\n\ 277 + \ type t = { id: Base.id; name: string }\n\ 278 + \ let create id name = { id; name }\n\ 279 + end;;" in 280 + test "graph_g2" (List.length errors = 0) 281 + (Printf.sprintf "%d errors" (List.length errors)); 282 + 283 + let* errors = query_errors rpc "" (Some "g3") ["g1"] 284 + "module Item = struct\n\ 285 + \ type t = { id: Base.id; value: int }\n\ 286 + \ let create id value = { id; value }\n\ 287 + end;;" in 288 + test "graph_g3" (List.length errors = 0) 289 + (Printf.sprintf "%d errors" (List.length errors)); 290 + 291 + (* g4 needs g1 for Base module, plus g2 and g3 *) 292 + let* errors = query_errors rpc "" (Some "g4") ["g1"; "g2"; "g3"] 293 + "let user = User.create (Base.make_id 1) \"Alice\";;\n\ 294 + let item = Item.create (Base.make_id 100) 42;;" in 295 + test "graph_g4" (List.length errors = 0) 296 + (Printf.sprintf "%d errors" (List.length errors)); 297 + 298 + Printf.printf "\n--- Section 7: Empty and Self Dependencies ---\n%!"; 299 + 300 + (* Cell with no deps *) 301 + let* errors = query_errors rpc "" (Some "e1") [] 302 + "let standalone = 999;;" in 303 + test "empty_deps" (List.length errors = 0) 304 + (Printf.sprintf "%d errors" (List.length errors)); 305 + 306 + (* Cell that tries to reference itself should fail or have errors *) 307 + let* errors = query_errors rpc "" (Some "self") [] 308 + "let self_ref = 1;;" in 309 + test "self_define" (List.length errors = 0) 310 + (Printf.sprintf "%d errors" (List.length errors)); 311 + 312 + IdlM.ErrM.return () 313 + in 314 + 315 + let promise = test_sequence |> IdlM.T.get in 316 + (match Lwt.state promise with 317 + | Lwt.Return (Ok ()) -> () 318 + | Lwt.Return (Error (InternalError s)) -> 319 + Printf.printf "\n[ERROR] Test failed with: %s\n%!" s 320 + | Lwt.Fail e -> 321 + Printf.printf "\n[ERROR] Exception: %s\n%!" (Printexc.to_string e) 322 + | Lwt.Sleep -> Printf.printf "\n[ERROR] Promise still pending\n%!"); 323 + 324 + Printf.printf "\n=== Results: %d/%d tests passed ===\n%!" !passed_tests 325 + !total_tests; 326 + if !passed_tests = !total_tests then 327 + Printf.printf "SUCCESS: All dependency tests passed!\n%!" 328 + else Printf.printf "FAILURE: Some tests failed.\n%!"