fastws-cli 0.0.34__tar.gz → 0.0.35__tar.gz

{fastws_cli-0.0.34 → fastws_cli-0.0.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastws-cli
-Version: 0.0.34
+Version: 0.0.35
 Summary: Fast workspace tools for multi-repo management
 Author: Jeremy Howard
 License-Expression: Apache-2.0
@@ -256,7 +256,11 @@ Use it when another process's unfinished edits stop the workspace compiling, suc
 
 ### Rust builds and tests from Python
 
-`fastws.cargo.run_tests` builds native tests once with Cargo, without a time limit, then runs the executables that Cargo reports directly from their package directories. Each binary gets its own `timeout`, 30 seconds by default, excluding compilation. A binary still running when its `timeout` ends is killed and counts as a failed binary, with its suite's `timed_out` set. Source edits between building and running do not trigger another build: the results describe the compiled build, not necessarily the latest working tree. It supports directly runnable native tests, not cross-target runners.
+`fastws.cargo.run_tests` builds native tests once with Cargo, without a time limit, then runs the executables that Cargo reports directly from their package directories. Each binary gets its own `timeout`, 30 seconds by default, excluding compilation. Outside `FASTWS_JOB`, a timed-out binary is reported as a failed suite with `timed_out` set. Inside a marked job, its timeout raises so the job owner can clean up descendants. Source edits between building and running do not trigger another build: the results describe the compiled build, not necessarily the latest working tree. It supports directly runnable native tests, not cross-target runners.
+
+Where a root has `.config/nextest.toml`, `cargo nextest run` runs the built tests instead: each test in its own process, every binary at once, with the config's slow-test timeouts and groups. `profiles` lists the nextest profiles to run one after another, `('default',)` unless given. `timeout` bounds each profile's run, and each binary's results come from nextest's JUnit report, which lists no ignored tests. `--profile NAME` passes to nextest as `--cargo-profile NAME`, and `test_args` follow `--`.
+
+`root` can also be a list of roots, which build one after another. Roots without nextest then run their binaries in turn. Each profile then runs at the same time in every root whose config defines it: tests in different roots share a phase, and no phase starts before the previous one ends. Suite names start with the root's directory name, and with several profiles also with the profile, as in `app timed: tests/speed.rs`. A failure ends the run after its profile unless `--no-fail-fast` is given.
 
 The default profile is `[tool.fastws].dev-profile`, or `test` when unset. Explicit `--profile NAME`, `--profile=NAME`, `--release` and `-r` override it. Pass Cargo build/selection options positionally, and test filters and harness options in `test_args`. A failed binary stops the run unless `--no-fail-fast` is given. Results contain compiler diagnostics and each binary's outcomes and captured failures.
 
@@ -265,6 +269,7 @@ from fastws.cargo import run_tests
 
 native = run_tests('.', '--no-fail-fast')
 focused = run_tests('.', '--test', 'core', test_args=('test_name', '--nocapture'))
+phased = run_tests(['app', 'lib'], profiles=('untimed', 'timed'))
 ```
 
 Doctests are deliberately not run; keep executable examples in ordinary Rust tests. `run_tests` accepts `env` overrides and `timeout=None` to disable its watchdog. It takes no timing lock around the run: rustc's wrapper owns its shared holds, and tests that time own their exclusive holds.
@@ -314,7 +319,7 @@ Fastws maintains `tool.uv.workspace.exclude`. It excludes unlisted top-level dir
 
 Existing globs, entries for missing directories, and entries for checkouts that are still not Python projects are retained. Use `exclude = [...]` under `[tool.fastws]` to specify exclusions the scan cannot infer, such as keeping a valid project out of the workspace. Adding members preserves hand-written `[tool.uv.sources]` entries, including path and Git sources.
 
-Each sync regenerates Cargo overrides in the workspace's `.cargo/config.toml`. `[patch.crates-io]` gets an entry for each local crate, including nested Cargo workspace members, except a crate marked `publish = false`, which never comes from crates.io. Git dependencies that name local crates get entries under the matching URL. Builds under the workspace root use these local checkouts. Entries pointing outside the root and other configuration sections are preserved.
+Each sync regenerates Cargo overrides in the workspace's `.cargo/config.toml`. `[patch.crates-io]` gets an entry for each local crate, including nested Cargo workspace members, that some local manifest requires from crates.io: by version alone, without `path`, `git` or `workspace`, in any dependency table or `[workspace.dependencies]`. Git dependencies that name local crates get entries under the matching URL. Builds under the workspace root use these local checkouts. Entries pointing outside the root and other configuration sections are preserved.
 
 Sync also defaults `[term] quiet = true` in that file to suppress routine Cargo output and warnings. An explicit `quiet = false` is preserved.
 

{fastws_cli-0.0.34 → fastws_cli-0.0.35}/README.md

@@ -228,7 +228,11 @@ Use it when another process's unfinished edits stop the workspace compiling, suc
 
 ### Rust builds and tests from Python
 
-`fastws.cargo.run_tests` builds native tests once with Cargo, without a time limit, then runs the executables that Cargo reports directly from their package directories. Each binary gets its own `timeout`, 30 seconds by default, excluding compilation. A binary still running when its `timeout` ends is killed and counts as a failed binary, with its suite's `timed_out` set. Source edits between building and running do not trigger another build: the results describe the compiled build, not necessarily the latest working tree. It supports directly runnable native tests, not cross-target runners.
+`fastws.cargo.run_tests` builds native tests once with Cargo, without a time limit, then runs the executables that Cargo reports directly from their package directories. Each binary gets its own `timeout`, 30 seconds by default, excluding compilation. Outside `FASTWS_JOB`, a timed-out binary is reported as a failed suite with `timed_out` set. Inside a marked job, its timeout raises so the job owner can clean up descendants. Source edits between building and running do not trigger another build: the results describe the compiled build, not necessarily the latest working tree. It supports directly runnable native tests, not cross-target runners.
+
+Where a root has `.config/nextest.toml`, `cargo nextest run` runs the built tests instead: each test in its own process, every binary at once, with the config's slow-test timeouts and groups. `profiles` lists the nextest profiles to run one after another, `('default',)` unless given. `timeout` bounds each profile's run, and each binary's results come from nextest's JUnit report, which lists no ignored tests. `--profile NAME` passes to nextest as `--cargo-profile NAME`, and `test_args` follow `--`.
+
+`root` can also be a list of roots, which build one after another. Roots without nextest then run their binaries in turn. Each profile then runs at the same time in every root whose config defines it: tests in different roots share a phase, and no phase starts before the previous one ends. Suite names start with the root's directory name, and with several profiles also with the profile, as in `app timed: tests/speed.rs`. A failure ends the run after its profile unless `--no-fail-fast` is given.
 
 The default profile is `[tool.fastws].dev-profile`, or `test` when unset. Explicit `--profile NAME`, `--profile=NAME`, `--release` and `-r` override it. Pass Cargo build/selection options positionally, and test filters and harness options in `test_args`. A failed binary stops the run unless `--no-fail-fast` is given. Results contain compiler diagnostics and each binary's outcomes and captured failures.
 
@@ -237,6 +241,7 @@ from fastws.cargo import run_tests
 
 native = run_tests('.', '--no-fail-fast')
 focused = run_tests('.', '--test', 'core', test_args=('test_name', '--nocapture'))
+phased = run_tests(['app', 'lib'], profiles=('untimed', 'timed'))
 ```
 
 Doctests are deliberately not run; keep executable examples in ordinary Rust tests. `run_tests` accepts `env` overrides and `timeout=None` to disable its watchdog. It takes no timing lock around the run: rustc's wrapper owns its shared holds, and tests that time own their exclusive holds.
@@ -286,7 +291,7 @@ Fastws maintains `tool.uv.workspace.exclude`. It excludes unlisted top-level dir
 
 Existing globs, entries for missing directories, and entries for checkouts that are still not Python projects are retained. Use `exclude = [...]` under `[tool.fastws]` to specify exclusions the scan cannot infer, such as keeping a valid project out of the workspace. Adding members preserves hand-written `[tool.uv.sources]` entries, including path and Git sources.
 
-Each sync regenerates Cargo overrides in the workspace's `.cargo/config.toml`. `[patch.crates-io]` gets an entry for each local crate, including nested Cargo workspace members, except a crate marked `publish = false`, which never comes from crates.io. Git dependencies that name local crates get entries under the matching URL. Builds under the workspace root use these local checkouts. Entries pointing outside the root and other configuration sections are preserved.
+Each sync regenerates Cargo overrides in the workspace's `.cargo/config.toml`. `[patch.crates-io]` gets an entry for each local crate, including nested Cargo workspace members, that some local manifest requires from crates.io: by version alone, without `path`, `git` or `workspace`, in any dependency table or `[workspace.dependencies]`. Git dependencies that name local crates get entries under the matching URL. Builds under the workspace root use these local checkouts. Entries pointing outside the root and other configuration sections are preserved.
 
 Sync also defaults `[term] quiet = true` in that file to suppress routine Cargo output and warnings. An explicit `quiet = false` is preserved.
 

{fastws_cli-0.0.34 → fastws_cli-0.0.35}/fastws/__init__.py

@@ -1,4 +1,5 @@
-__version__ = "0.0.34"
+__version__ = "0.0.35"
+
 
 
 

{fastws_cli-0.0.34 → fastws_cli-0.0.35}/fastws/cargo.py

@@ -1,11 +1,13 @@
 r"Build, test and install Cargo artifacts for mixed Rust/Python projects."
-import json, os, re, shutil, signal, subprocess, sys, sysconfig, time
+import json, os, re, shutil, signal, subprocess, sys, sysconfig, tempfile, time
 from collections import Counter
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import NamedTuple
+from xml.etree import ElementTree
 from . import store
-from .procs import bounded
+from .procs import bounded, JOB_ENV
 from ._toml import tomllib
 
 
@@ -143,32 +145,115 @@ def check(
     return Results(args[0], *_run(Path(root).expanduser(), args, env, diagnostics)[:3])
 
 
-def run_tests(
-    root, # A Cargo package or workspace (expands `~`)
-    *args, # Cargo build/selection options, such as `'--test', 'core'` or `'--profile', 'checked'`; `--no-fail-fast` runs every binary
-    test_args=(), # Arguments passed directly to each test binary, such as `('name', '--nocapture')`
-    env:dict=None, # Environment variables to set for the run, such as `{'BASEDPL_COSTS': '1'}`
-    timeout:float=30 # Seconds that each native test binary may run after building; None: no limit
-)->Results:
-    "Build native tests once, with no time limit, then run Cargo's reported executables directly from their package directories. Source edits after building cannot trigger another build; results describe the compiled build, not the latest working tree. `timeout` bounds each binary on its own, excluding compilation. A binary that runs out of time is killed and reported as a failed binary whose suite is `timed_out`. An omitted profile uses tool.fastws.dev-profile, or test. Doctests are not run. This takes no timing lock: rustc's wrapper and tests that time own their holds."
-    root, env = Path(root).expanduser().resolve(), {'CARGO_TERM_QUIET': 'false', 'CARGO_TERM_COLOR': 'never'} | (env or {})
-    has_profile = any(a in ('-r', '--release', '--profile') or isinstance(a, str) and a.startswith('--profile=') for a in args)
-    if not has_profile: args += ('--profile', _dev_profile(root))
-    code, text, found, rest = _run(root, ('test', '--no-run', *args), env)
-    if code: return Results('test', code, text, found)
-    artifacts = [m for m in rest if m['reason'] == 'compiler-artifact' and m['profile']['test'] and m.get('executable')]
-    suites, code, start = [], 0, time.monotonic()
+def _bounded(cmd, timeout, **kwargs):
+    "`bounded(cmd, timeout, merge=True, **kwargs)`, and whether it ran out of time. Outside `FASTWS_JOB`, a timeout gives a killed process's result; inside a marked job, it raises so the job's owner can clean up descendants."
+    try: return bounded(cmd, timeout, merge=True, **kwargs), False
+    except TimeoutError as e:
+        if os.environ.get(JOB_ENV): raise
+        return subprocess.CompletedProcess(cmd, -signal.SIGKILL, f'{e}\n'), True
+
+
+def _suite_name(m):
+    "The `Suite` name of the test binary that Cargo artifact `m` describes: its target's source, prefixed `unittests ` unless it's an integration test."
+    name = Path(m['target']['src_path']).relative_to(Path(m['manifest_path']).parent).as_posix()
+    return name if 'test' in m['target']['kind'] else 'unittests ' + name
+
+
+def _binary_id(m, packages):
+    "nextest's id for the test binary that Cargo artifact `m` describes, such as `app`, `app::more` or `app::bin/app`. `packages` maps package ids to names."
+    pkg, kind, name = packages[m['package_id']], m['target']['kind'][0], m['target']['name']
+    if kind == 'test': return f'{pkg}::{name}'
+    return f'{pkg}::{kind}/{name}' if kind in ('bin', 'example', 'bench') else pkg
+
+
+def _junit(path, names):
+    "Each binary's `Suite` from nextest's JUnit report at `path`. `names` maps nextest's binary ids to suite names. Ignored tests don't appear."
+    suites = []
+    for ts in ElementTree.parse(path).getroot().iter('testsuite'):
+        tests, failures, late = {}, {}, False
+        for tc in ts.iter('testcase'):
+            t, bad = tc.get('name'), next(iter(tc.findall('failure') + tc.findall('error')), None)
+            tests[t] = 'ok' if bad is None else 'FAILED'
+            if bad is None: continue
+            failures[t] = '\n'.join(s for s in (tc.findtext('system-out', '').strip('\n'), tc.findtext('system-err', '').strip('\n') or bad.text or '') if s)
+            late |= 'timeout' in bad.get('type', '')
+        suites.append(Suite(names.get(ts.get('name'), ts.get('name')), '\n\n'.join(failures.values()), tests, failures, '', bool(failures), late))
+    return suites
+
+
+def _nextest(root, args, test_args, env, timeout, artifacts, profile='default'):
+    "Run the built tests with `cargo nextest run --profile profile` under `timeout` as a whole: its exit status, its output, each binary's `Suite` and the run's seconds. Cargo's `--profile` in `args` becomes nextest's `--cargo-profile`."
+    packages = {p['id']: p['name'] for p in json.loads(cargo(root, 'metadata', '--format-version', '1', '--no-deps'))['packages']}
+    names = {_binary_id(m, packages): _suite_name(m) for m in artifacts}
+    args = [re.sub(r'^--profile(?==|$)', '--cargo-profile', a) for a in map(str, args)]
+    with tempfile.TemporaryDirectory() as d:
+        report, tool = Path(d)/'junit.xml', Path(d)/'fastws.toml'
+        tool.write_text(f'[profile.{profile}.junit]\npath = {json.dumps(str(report))}\n')
+        cmd = ['cargo', 'nextest', 'run', '--tool-config-file', f'fastws:{tool}', '--profile', profile, '--show-progress=none', '--color=never', *args, *(('--', *test_args) if test_args else ())]
+        start = time.monotonic()
+        p, late = _bounded(cmd, timeout, cwd=root, env=os.environ | env)
+        suites = _junit(report, names) if report.exists() else [Suite('nextest', p.stdout, {}, {}, '', True, late)]
+    return p.returncode, p.stdout, suites, time.monotonic() - start
+
+
+def _libtest(root, args, test_args, env, timeout, artifacts):
+    "Run each built test binary in turn from its package directory under `timeout`: the first failing exit status, the output and each binary's `Suite`. Without `--no-fail-fast` in `args`, the first failing binary ends the run."
+    code, text, suites = 0, '', []
     for m in artifacts:
-        package = Path(m['manifest_path']).parent
-        name = Path(m['target']['src_path']).relative_to(package).as_posix()
-        if 'test' not in m['target']['kind']: name = 'unittests ' + name
-        try: p, late = bounded([m['executable'], *test_args], timeout, merge=True, cwd=package, env=os.environ | env | {'CARGO_MANIFEST_DIR': str(package)}), False
-        except TimeoutError as e: p, late = subprocess.CompletedProcess(m['executable'], -signal.SIGKILL, f'{e}\n'), True
+        package, name = Path(m['manifest_path']).parent, _suite_name(m)
+        p, late = _bounded([m['executable'], *test_args], timeout, cwd=package, env=os.environ | env | {'CARGO_MANIFEST_DIR': str(package)})
         suites.append(Suite.read(name, p.stdout.splitlines(), p.returncode, late))
         text += f'     Running {name} ({m["executable"]})\n' + p.stdout
         if p.returncode:
-            code = p.returncode
+            code = code or p.returncode
             if '--no-fail-fast' not in args: break
+    return code, text, suites
+
+
+def _nextest_profiles(root):
+    "The nextest profiles that `root`'s `.config/nextest.toml` defines, `default` included, or None without that file."
+    config = root/'.config/nextest.toml'
+    return {'default', *tomllib.loads(config.read_text()).get('profile', {})} if config.exists() else None
+
+
+def run_tests(
+    root, # A Cargo package or workspace (expands `~`), or a list of them
+    *args, # Cargo build/selection options, such as `'--test', 'core'` or `'--profile', 'checked'`; `--no-fail-fast` runs every binary
+    test_args=(), # Arguments passed directly to each test binary, such as `('name', '--nocapture')`; nextest gets them after `--`
+    env:dict=None, # Environment variables to set for the run, such as `{'BASEDPL_COSTS': '1'}`
+    timeout:float=30, # Seconds that each native test binary, or each nextest run of one profile in one root, may take after building; None: no limit
+    profiles:tuple=('default',) # The nextest profiles to run in turn, each at once in every root whose `.config/nextest.toml` defines it
+)->Results:
+    "Build native tests once per root, with no time limit, then run Cargo's reported executables directly from their package directories. Where a root has `.config/nextest.toml`, `cargo nextest run` runs them instead, each test in its own process, once for each of `profiles` that its config defines, and each binary's results come from nextest's JUnit report. Several roots build in turn. Roots without nextest then run in turn, and each profile then runs in every root that defines it at once. Without `--no-fail-fast`, a failure ends the run after its binary, or after its profile. With several roots, each suite's name starts with its root's directory name, and with several profiles, with the profile. Source edits after building cannot trigger another build; results describe the compiled build, not the latest working tree. `timeout` bounds each binary, or each root's run of a profile, excluding compilation. Outside `FASTWS_JOB`, a run that runs out of time is reported as a failed suite with `timed_out` set. Inside a marked job, the timeout raises so its owner can clean up descendants. An omitted Cargo profile uses each root's tool.fastws.dev-profile, or test. Doctests are not run. This takes no timing lock: rustc's wrapper and tests that time own their holds."
+    roots = [Path(r).expanduser().resolve() for r in (root if isinstance(root, (list, tuple)) else [root])]
+    env = {'CARGO_TERM_QUIET': 'false', 'CARGO_TERM_COLOR': 'never'} | (env or {})
+    has_profile = any(a in ('-r', '--release', '--profile') or isinstance(a, str) and a.startswith('--profile=') for a in args)
+    text, found, built = '', [], []
+    for r in roots:
+        rargs = args if has_profile else (*args, '--profile', _dev_profile(r))
+        code, out, diags, rest = _run(r, ('test', '--no-run', *rargs), env)
+        text, found = text + out, found + diags
+        if code: return Results('test', code, text, found)
+        artifacts = [m for m in rest if m['reason'] == 'compiler-artifact' and m['profile']['test'] and m.get('executable')]
+        built.append((r, rargs, artifacts, _nextest_profiles(r)))
+    def named(r, p, suites):
+        "`suites`, freshly read, renamed for root `r` and profile `p` where several roots or profiles ran"
+        t = ' '.join(x for x in (r.name if len(roots) > 1 else '', p if p and len(profiles) > 1 else '') if x)
+        for s in suites: s.name = f'{t}: {s.name}' if t else s.name
+        return t, suites
+    fail_fast, code, suites, start = '--no-fail-fast' not in args, 0, [], time.monotonic()
+    for r, rargs, artifacts, defined in built:
+        if defined is not None: continue
+        c, out, ss = _libtest(r, rargs, test_args, env, timeout, artifacts)
+        text, suites, code = text + out, suites + named(r, None, ss)[1], code or c
+        if code and fail_fast: return Results('test', code, text, found, suites, time.monotonic() - start)
+    for p in profiles:
+        jobs = [(r, rargs, artifacts) for r, rargs, artifacts, defined in built if p in (defined or ())]
+        with ThreadPoolExecutor(max(len(jobs), 1)) as ex: runs = list(ex.map(lambda j: _nextest(j[0], j[1], test_args, env, timeout, j[2], p), jobs))
+        for (r, _, _), (c, out, ss, _) in zip(jobs, runs):
+            t, ss = named(r, p, ss)
+            text, suites, code = text + (f'     Nextest profile {p} in {r}\n' if t else '') + out, suites + ss, code or c
+        if code and fail_fast: break
     return Results('test', code, text, found, suites, time.monotonic() - start)
 
 

{fastws_cli-0.0.34 → fastws_cli-0.0.35}/fastws/core.py

@@ -684,20 +684,31 @@ def _cargo_patches(root: Path):
             patches[(_repo_key(url), name)] = path if path.is_absolute() else (config.parent/path).resolve()
     return patches, config
 
-def _crate_pkgs(d: Path):
-    "(`[package]` table, dir) for the crate at `d` and its cargo workspace members"
+def _crate_manifests(d: Path):
+    "(parsed `Cargo.toml`, dir) for the crate or workspace at `d` and each of its cargo workspace members"
     try: data = tomllib.loads((d/"Cargo.toml").read_text())
     except tomllib.TOMLDecodeError: return
-    if "name" in (pkg := data.get("package", {})): yield pkg, d
+    yield data, d
     for m in _project_dirs(d, "Cargo.toml", data.get("workspace", {}).get("members", [])):
         try: sub = tomllib.loads((m/"Cargo.toml").read_text())
         except tomllib.TOMLDecodeError: continue
-        if "name" in (pkg := sub.get("package", {})): yield pkg, m
+        yield sub, m
+
+def _crate_pkgs(d: Path):
+    "(`[package]` table, dir) for the crate at `d` and its cargo workspace members"
+    for data, m in _crate_manifests(d):
+        if "name" in (pkg := data.get("package", {})): yield pkg, m
 
 def _local_crates(root: Path) -> list[tuple[dict, Path]]:
     "(`[package]` table, dir) for every crate under `root`, nested cargo workspace members included"
     return [p for crate in _crate_dirs(root) for p in _crate_pkgs(crate)]
 
+def _registry_requirements(root: Path) -> set[str]:
+    "Packages that some manifest under `root` requires from crates.io: a version with no `path`, `git`, `registry` or `workspace` key"
+    return {spec.get("package", name) if isinstance(spec, dict) else name
+            for crate in _crate_dirs(root) for data, _ in _crate_manifests(crate) for deps in _cargo_dep_tables(data, every=True)
+            for name, spec in deps.items() if isinstance(spec, str) or isinstance(spec, dict) and not {"path", "git", "registry", "workspace"} & spec.keys()}
+
 def _git_dep_tables(root: Path, crates: dict[str, Path]) -> dict[str, dict[str, Path]]:
     "Git URL -> {package: local dir} for members' git deps that name a local crate"
     res = {}
@@ -741,15 +752,16 @@ def cargo_setup(root):
 def _sync_cargo_patches(root: Path) -> tuple[list[str], list[str]]:
     """Regenerate workspace Cargo patches, default to quiet output, and return (added, removed).
 
-    Every local crate gets a `[patch.crates-io]` entry, except one marked `publish = false`, which never comes
-    from crates.io. A member's git dep on a local crate gets an entry under that URL. Builds anywhere under `root`
-    then use the checkouts: the cargo analog of editable installs. Only entries whose path is inside `root` are
-    managed; entries pointing elsewhere (and any other config sections) are kept as-is, and a kept entry wins
-    over a generated one of the same name."""
+    A local crate gets a `[patch.crates-io]` entry only where some local manifest requires it from crates.io
+    (`_registry_requirements`); Cargo uses no other patch. A member's git dep on a local crate gets an entry under
+    that URL. Builds anywhere under `root` then use the checkouts: the cargo analog of editable installs. Only
+    entries whose path is inside `root` are managed; entries pointing elsewhere (and any other config sections) are
+    kept as-is, and a kept entry wins over a generated one of the same name."""
     root = root.resolve()
     pkgs = _local_crates(root)
     crates = {pkg["name"]: d for pkg, d in pkgs}
-    desired = {"crates-io": {pkg["name"]: str(d) for pkg, d in pkgs if pkg.get("publish") is not False}}
+    required = _registry_requirements(root)
+    desired = {"crates-io": {name: str(d) for name, d in crates.items() if name in required}}
     for url, entries in _git_dep_tables(root, crates).items(): desired[url] = {name: str(d) for name, d in entries.items()}
     config = root/".cargo"/"config.toml"
     original = content = config.read_text() if config.exists() else ""
@@ -816,10 +828,13 @@ def _sync_cargo_wrapper(root: Path):
     config.parent.mkdir(exist_ok=True)
     config.write_text(new)
 
-def _cargo_dep_tables(data):
-    for name in "dependencies","build-dependencies": yield data.get(name, {})
+def _cargo_dep_tables(data, every=False):
+    "A manifest's dependency and build-dependency tables, top-level and per target; with `every`, its dev-dependency tables and `[workspace.dependencies]` too"
+    names = ("dependencies", "build-dependencies", "dev-dependencies")[:3 if every else 2]
+    for name in names: yield data.get(name, {})
     for target in data.get("target", {}).values():
-        for name in "dependencies","build-dependencies": yield target.get(name, {})
+        for name in names: yield target.get(name, {})
+    if every: yield data.get("workspace", {}).get("dependencies", {})
 
 def _patched_cargo_deps(crate: Path, patches):
     data = tomllib.loads((crate/"Cargo.toml").read_text())
@@ -942,8 +957,10 @@ def _npm_install(root: Path):
     except json.JSONDecodeError:
         print(res.stdout, file=sys.stderr, end="")
         raise
-    if data.get("audit", {}).get("vulnerabilities", {}).get("total") or data.get("unreviewedScripts"):
-        print(f"npm install findings ({root}):\n{res.stdout}", file=sys.stderr, end="")
+    findings = {}
+    if data.get("audit", {}).get("vulnerabilities", {}).get("total"): findings["audit"] = data["audit"]
+    if data.get("unreviewedScripts"): findings["unreviewedScripts"] = data["unreviewedScripts"]
+    if findings: print(f"npm install findings ({root}):\n{json.dumps(findings, indent=2)}", file=sys.stderr)
 
 def _sync_js(root: Path, members: list[Path]) -> list[Path]:
     "Install the JS workspace, run every native member's build script, and return those members. Cargo handles incremental compilation."

{fastws_cli-0.0.34 → fastws_cli-0.0.35}/fastws_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastws-cli
-Version: 0.0.34
+Version: 0.0.35
 Summary: Fast workspace tools for multi-repo management
 Author: Jeremy Howard
 License-Expression: Apache-2.0
@@ -256,7 +256,11 @@ Use it when another process's unfinished edits stop the workspace compiling, suc
 
 ### Rust builds and tests from Python
 
-`fastws.cargo.run_tests` builds native tests once with Cargo, without a time limit, then runs the executables that Cargo reports directly from their package directories. Each binary gets its own `timeout`, 30 seconds by default, excluding compilation. A binary still running when its `timeout` ends is killed and counts as a failed binary, with its suite's `timed_out` set. Source edits between building and running do not trigger another build: the results describe the compiled build, not necessarily the latest working tree. It supports directly runnable native tests, not cross-target runners.
+`fastws.cargo.run_tests` builds native tests once with Cargo, without a time limit, then runs the executables that Cargo reports directly from their package directories. Each binary gets its own `timeout`, 30 seconds by default, excluding compilation. Outside `FASTWS_JOB`, a timed-out binary is reported as a failed suite with `timed_out` set. Inside a marked job, its timeout raises so the job owner can clean up descendants. Source edits between building and running do not trigger another build: the results describe the compiled build, not necessarily the latest working tree. It supports directly runnable native tests, not cross-target runners.
+
+Where a root has `.config/nextest.toml`, `cargo nextest run` runs the built tests instead: each test in its own process, every binary at once, with the config's slow-test timeouts and groups. `profiles` lists the nextest profiles to run one after another, `('default',)` unless given. `timeout` bounds each profile's run, and each binary's results come from nextest's JUnit report, which lists no ignored tests. `--profile NAME` passes to nextest as `--cargo-profile NAME`, and `test_args` follow `--`.
+
+`root` can also be a list of roots, which build one after another. Roots without nextest then run their binaries in turn. Each profile then runs at the same time in every root whose config defines it: tests in different roots share a phase, and no phase starts before the previous one ends. Suite names start with the root's directory name, and with several profiles also with the profile, as in `app timed: tests/speed.rs`. A failure ends the run after its profile unless `--no-fail-fast` is given.
 
 The default profile is `[tool.fastws].dev-profile`, or `test` when unset. Explicit `--profile NAME`, `--profile=NAME`, `--release` and `-r` override it. Pass Cargo build/selection options positionally, and test filters and harness options in `test_args`. A failed binary stops the run unless `--no-fail-fast` is given. Results contain compiler diagnostics and each binary's outcomes and captured failures.
 
@@ -265,6 +269,7 @@ from fastws.cargo import run_tests
 
 native = run_tests('.', '--no-fail-fast')
 focused = run_tests('.', '--test', 'core', test_args=('test_name', '--nocapture'))
+phased = run_tests(['app', 'lib'], profiles=('untimed', 'timed'))
 ```
 
 Doctests are deliberately not run; keep executable examples in ordinary Rust tests. `run_tests` accepts `env` overrides and `timeout=None` to disable its watchdog. It takes no timing lock around the run: rustc's wrapper owns its shared holds, and tests that time own their exclusive holds.
@@ -314,7 +319,7 @@ Fastws maintains `tool.uv.workspace.exclude`. It excludes unlisted top-level dir
 
 Existing globs, entries for missing directories, and entries for checkouts that are still not Python projects are retained. Use `exclude = [...]` under `[tool.fastws]` to specify exclusions the scan cannot infer, such as keeping a valid project out of the workspace. Adding members preserves hand-written `[tool.uv.sources]` entries, including path and Git sources.
 
-Each sync regenerates Cargo overrides in the workspace's `.cargo/config.toml`. `[patch.crates-io]` gets an entry for each local crate, including nested Cargo workspace members, except a crate marked `publish = false`, which never comes from crates.io. Git dependencies that name local crates get entries under the matching URL. Builds under the workspace root use these local checkouts. Entries pointing outside the root and other configuration sections are preserved.
+Each sync regenerates Cargo overrides in the workspace's `.cargo/config.toml`. `[patch.crates-io]` gets an entry for each local crate, including nested Cargo workspace members, that some local manifest requires from crates.io: by version alone, without `path`, `git` or `workspace`, in any dependency table or `[workspace.dependencies]`. Git dependencies that name local crates get entries under the matching URL. Builds under the workspace root use these local checkouts. Entries pointing outside the root and other configuration sections are preserved.
 
 Sync also defaults `[term] quiet = true` in that file to suppress routine Cargo output and warnings. An explicit `quiet = false` is preserved.
 

{fastws_cli-0.0.34 → fastws_cli-0.0.35}/tests/test_build.py

@@ -1,4 +1,4 @@
-import subprocess, pytest, fastws.core as core
+import shutil, subprocess, pytest, fastws.core as core
 from fastws.cargo import build, check, run_tests, Suite
 
 
@@ -46,10 +46,10 @@ def test_build_diagnostics(tmp_path, capfd, body, diagnostic):
     assert checked.ok == (diagnostic != 'error') and [(d.path, d.level) for d in checked.diagnostics] == ([('dep/src/lib.rs', diagnostic)] if diagnostic else [])
 
 
-def test_run_tests(tmp_path):
-    (tmp_path/'Cargo.toml').write_text('[package]\nname = "app"\nversion = "0.1.0"\nedition = "2021"\n')
-    (tmp_path/'src').mkdir()
-    (tmp_path/'src/lib.rs').write_text('''pub fn unused() { let x = 1; }
+def _test_crate(root):
+    (root/'Cargo.toml').write_text('[package]\nname = "app"\nversion = "0.1.0"\nedition = "2021"\n')
+    (root/'src').mkdir()
+    (root/'src/lib.rs').write_text('''pub fn unused() { let x = 1; }
 pub fn two() -> i32 { 2 }
 #[cfg(test)] mod t {
     #[test] fn passes() {}
@@ -60,10 +60,14 @@ pub fn two() -> i32 { 2 }
     }
 }
 ''')
-    (tmp_path/'tests').mkdir()
-    (tmp_path/'tests/more.rs').write_text('#[test] fn other() { assert_eq!(app::two(), 2); }\n')
-    (tmp_path/'.cargo').mkdir()
-    (tmp_path/'.cargo/config.toml').write_text('[term]\nquiet = true\n')
+    (root/'tests').mkdir()
+    (root/'tests/more.rs').write_text('#[test] fn other() { assert_eq!(app::two(), 2); }\n')
+    (root/'.cargo').mkdir()
+    (root/'.cargo/config.toml').write_text('[term]\nquiet = true\n')
+
+
+def test_run_tests(tmp_path):
+    _test_crate(tmp_path)
     r = run_tests(tmp_path, '--no-fail-fast')
     assert not r.ok
     assert [(d.path, d.line, d.level, d.code) for d in r.diagnostics] == [('src/lib.rs', 1, 'warning', 'unused_variables')]
@@ -85,6 +89,43 @@ pub fn two() -> i32 { 2 }
         assert run_tests(tmp_path, '--test', 'more', *args).ok
 
 
+@pytest.mark.skipif(not shutil.which('cargo-nextest'), reason='needs cargo-nextest')
+def test_run_tests_nextest(tmp_path):
+    _test_crate(tmp_path)
+    (tmp_path/'.config').mkdir()
+    (tmp_path/'.config/nextest.toml').write_text('[profile.default]\nfail-fast = false\n')
+    r = run_tests(tmp_path)
+    assert not r.ok and [(d.path, d.level) for d in r.diagnostics] == [('src/lib.rs', 'warning')]
+    suites = {s.name: s for s in r.suites}
+    unit, more = suites['unittests src/lib.rs'], suites['tests/more.rs']
+    assert unit.tests == {'t::passes': 'ok', 't::fails': 'FAILED'} and unit.failed and 'broken' in unit.failures['t::fails']
+    assert more.tests == {'other': 'ok'} and not more.failed
+    assert run_tests(tmp_path, '--test', 'more', '--profile', 'test').ok
+    slow = run_tests(tmp_path, '--lib', test_args=('skipped', '--ignored'), timeout=5)
+    s, = slow.suites
+    assert not slow.ok and s.timed_out and str(s) == 'nextest: ran out of time'
+
+
+@pytest.mark.skipif(not shutil.which('cargo-nextest'), reason='needs cargo-nextest')
+def test_run_tests_profiles(tmp_path):
+    a, b = tmp_path/'a', tmp_path/'b'
+    for d in a, b: (d/'.config').mkdir(parents=True)
+    _test_crate(a)
+    (a/'.config/nextest.toml').write_text('[profile.one]\ndefault-filter = "test(passes) | test(other)"\n[profile.two]\ndefault-filter = "test(fails)"\n')
+    (b/'Cargo.toml').write_text('[package]\nname = "b"\nversion = "0.1.0"\nedition = "2021"\n')
+    (b/'src').mkdir()
+    (b/'src/lib.rs').write_text('')
+    (b/'tests').mkdir()
+    (b/'tests/fine.rs').write_text('#[test] fn fine() {}\n')
+    (b/'.config/nextest.toml').write_text('[profile.one]\n')
+    r = run_tests([a, b], profiles=('one', 'two'))
+    tests = {s.name: s.tests for s in r.suites if s.tests}
+    assert not r.ok and tests == {'a one: unittests src/lib.rs': {'t::passes': 'ok'}, 'a one: tests/more.rs': {'other': 'ok'},
+                                  'b one: tests/fine.rs': {'fine': 'ok'}, 'a two: unittests src/lib.rs': {'t::fails': 'FAILED'}}
+    first = run_tests([a, b], profiles=('two', 'one'))
+    assert not first.ok and {s.name for s in first.suites if s.tests} == {'a two: unittests src/lib.rs'}
+
+
 def test_captured_test_output():
     for failed in (False, True):
         lines = ['test passes ... ok', 'successes:', '---- passes stdout ----', 'printed', 'successes:', 'passes']

{fastws_cli-0.0.34 → fastws_cli-0.0.35}/tests/test_integrate.py

@@ -27,6 +27,8 @@ def test_config_points_only_the_roots_crates_at_the_root(tmp_path):
         f'[build]\nrustc-wrapper = "/lock"\n\n[patch.crates-io]\na = {{ path = "{workspace}/a" }}\nb = {{ path = "{workspace}/b" }}\n')
     (root/"a").mkdir(parents=True)
     (root/"a"/"Cargo.toml").write_text('[package]\nname = "a"\nversion = "0.1.0"\n')
+    (root/"c").mkdir()
+    (root/"c"/"Cargo.toml").write_text('[package]\nname = "c"\nversion = "0.1.0"\n\n[dependencies]\na = "0.1"\n')
     _config(root, workspace)
     config = tomllib.loads((root/".cargo"/"config.toml").read_text())
     assert config["build"]["rustc-wrapper"] == "/lock"

{fastws_cli-0.0.34 → fastws_cli-0.0.35}/tests/test_procs.py

@@ -1,4 +1,4 @@
-import fcntl, os, subprocess, sys, pytest
+import fcntl, os, subprocess, sys, threading, pytest
 from fastws.procs import JOB_ENV, kill_group
 
 
@@ -25,10 +25,17 @@ time.sleep(60)
 '''
     with subprocess.Popen([sys.executable, '-c', job], start_new_session=True, env=os.environ | {JOB_ENV: '1'},
                           stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True) as p:
-        try:
-            with pytest.raises(subprocess.TimeoutExpired): p.communicate(timeout=.8)
+        lines, survived = [], threading.Event()
+        def read():
+            for line in p.stdout:
+                lines.append(line)
+                if line.startswith('job survived inner timeout'): survived.set()
+        reader = threading.Thread(target=read, daemon=True)
+        reader.start()
+        try: assert survived.wait(10), ''.join(lines)
         finally: kill_group(p)
-        output, _ = p.communicate(timeout=2)
+        reader.join(2)
+    output = ''.join(lines)
     group = output.split('job group ')[1].split()[0]
     assert f'child group {group} 1' in output and f'descendant group {group}' in output
     assert 'job survived inner timeout' in output

{fastws_cli-0.0.34 → fastws_cli-0.0.35}/tests/test_sync.py

@@ -171,24 +171,27 @@ def test_sync_cargo_patches_generates_and_preserves(tmp_path):
     config = tmp_path/'.cargo'/'config.toml'
     config.write_text('[term]\nquiet = true\n\n[patch.crates-io]\n'
         f'foreign = {{ path = "/elsewhere/foreign" }}\ngone = {{ path = "{tmp_path}/gone" }}\n')
-    crate1 = tmp_path/'crate1'
-    crate1.mkdir()
-    (crate1/'Cargo.toml').write_text('[package]\nname = "crate1"\nversion = "0.1.0"\n\n[dependencies]\nfamily = { git = "https://example.com/family" }\n')
+    crate1, helper = tmp_path/'crate1', tmp_path/'helper'
+    crate1.mkdir(); helper.mkdir()
+    (crate1/'Cargo.toml').write_text('[package]\nname = "crate1"\nversion = "0.1.0"\n\n[dependencies]\nfamily = { git = "https://example.com/family" }\n'
+        '\n[dev-dependencies]\nfamily-sub = { version = "0.1" }\n')
+    (helper/'Cargo.toml').write_text('[package]\nname = "helper"\nversion = "0.1.0"\n')
     family = tmp_path/'family'
     (family/'sub').mkdir(parents=True)
-    (family/'Cargo.toml').write_text('[package]\nname = "family"\nversion = "0.1.0"\npublish = false\n\n[workspace]\nmembers = ["sub"]\n')
+    (family/'Cargo.toml').write_text('[package]\nname = "family"\nversion = "0.1.0"\npublish = false\n\n[workspace]\nmembers = ["sub"]\n'
+        '\n[workspace.dependencies]\nhelper = "0.1"\ncrate1 = { path = "../crate1", version = "0.1" }\n')
     (family/'sub'/'Cargo.toml').write_text('[package]\nname = "family-sub"\nversion = "0.1.0"\n')
 
     added, removed = core._sync_cargo_patches(tmp_path)
     data = core.tomllib.loads(config.read_text())
     cio = data['patch']['crates-io']
-    assert set(cio) == {'foreign', 'crate1', 'family-sub'}  # `publish = false` crates never come from crates.io
+    assert set(cio) == {'foreign', 'family-sub', 'helper'}  # only crates that a local manifest requires from crates.io; `crate1` is required by path
     assert cio['foreign']['path'] == '/elsewhere/foreign'  # entries pointing outside the root are kept as-is
-    assert cio['crate1']['path'] == str(crate1)
-    assert cio['family-sub']['path'] == str(family/'sub')
+    assert cio['family-sub']['path'] == str(family/'sub')  # required as a dev-dependency
+    assert cio['helper']['path'] == str(helper)  # required in `[workspace.dependencies]`
     assert data['patch']['https://example.com/family']['family']['path'] == str(family)  # git deps on local crates get their URL table, published or not
     assert data['term']['quiet'] is True  # other sections untouched
-    assert set(added) == {'crate1', 'family', 'family-sub'} and removed == ['gone']
+    assert set(added) == {'family', 'family-sub', 'helper'} and removed == ['gone']
 
 
 def test_sync_ws_package_json_preserves_local_and_merges_shared(tmp_path):