ci: run unit tests for every crate, not just the root package

`default-members = ["."]` means a bare `cargo test` covers only the
root package. CI ran 30 of 321 unit tests, so every test in ember-core
and in the platform backend was green by omission, including the
thin_ls and `zfs list` parsing tests this branch added and the spec
lists as its no-root coverage.

`--workspace` is not the fix. It selects the other platform's backend
too, and that backend does not build here: ember-macos needs
`clonefile` on Linux, and on macOS ember-linux's image tests want
`mkfs.ext4`. Naming the packages per platform is what actually works,
matching how `build` already branches on UNAME.

`check` and `clippy` get the same selection, so test-module code is
compiled and linted too. That immediately caught an
`items_after_test_module` failure in this branch's own accounting
tests, now moved to the end of the file.

`build` and `release` stay as they are: they build the root package,
which pulls the platform crate and ember-core in as dependencies, so
naming them would compile nothing new.

CI calls `make test` rather than `cargo test`, so the lint, check, and
test entry points stay consistent.

Author: aljoscha

.github/workflows/ci.yml

@@ -32,8 +32,8 @@ jobs:
       - name: make clippy
         run: make clippy
 
-      - name: cargo test
-        run: cargo test
+      - name: make test
+        run: make test
 
       - name: cargo fmt -- --check
         run: cargo fmt -- --check

Makefile

@@ -4,6 +4,20 @@
 
 UNAME := $(shell uname -s)
 
+# Which workspace members to check, lint, and test.
+#
+# `default-members = ["."]` in Cargo.toml means a bare `cargo test` only
+# covers the root package, so the unit tests in ember-core and the
+# platform crate never run. `--workspace` is not the fix: it selects the
+# other platform's backend too, and that backend does not compile here
+# (ember-macos needs `clonefile`, ember-linux's image tests need
+# `mkfs.ext4`). Naming the packages is what actually works.
+ifeq ($(UNAME),Darwin)
+PACKAGES := -p ember -p ember-core -p ember-macos
+else
+PACKAGES := -p ember -p ember-core -p ember-linux
+endif
+
 .PHONY: build release clean fmt check clippy test udeps
 
 build:
@@ -32,13 +46,13 @@ fmt:
 	cargo fmt
 
 check:
-	cargo check
+	cargo check --all-targets $(PACKAGES)
 
 clippy:
-	cargo clippy --all-targets -- -D warnings
+	cargo clippy --all-targets $(PACKAGES) -- -D warnings
 
 test:
-	cargo test
+	cargo test $(PACKAGES)
 
 udeps:
 	cargo machete

crates/ember-core/src/backend.rs

@@ -162,90 +162,6 @@ pub struct StorageUsage {
     pub images: BTreeMap<String, VolumeUsage>,
 }
 
-#[cfg(test)]
-mod usage_tests {
-    use super::*;
-
-    fn volume(exclusive: u64, referenced: Option<u64>, logical: Option<u64>) -> VolumeUsage {
-        VolumeUsage {
-            provisioned: 1024,
-            exclusive,
-            referenced,
-            logical,
-        }
-    }
-
-    #[test]
-    fn shared_is_the_gap_between_referenced_and_exclusive() {
-        assert_eq!(volume(80, Some(100), None).shared(), Some(20));
-        assert_eq!(volume(100, Some(100), None).shared(), Some(0));
-    }
-
-    /// Backends that cannot separate shared from exclusive report
-    /// nothing rather than claiming zero sharing.
-    #[test]
-    fn shared_is_unknown_without_referenced() {
-        assert_eq!(volume(80, None, None).shared(), None);
-    }
-
-    /// `exclusive` is contractually within `referenced`, but the
-    /// saturating subtraction keeps a backend bug from producing a
-    /// wrapped, astronomically large shared figure.
-    #[test]
-    fn shared_saturates_instead_of_wrapping() {
-        assert_eq!(volume(120, Some(100), None).shared(), Some(0));
-    }
-
-    #[test]
-    fn compression_ratio_divides_logical_by_referenced() {
-        let r = volume(80, Some(100), Some(200)).compression_ratio();
-        assert_eq!(r, Some(2.0));
-    }
-
-    /// An untouched volume would divide by zero. `None` renders as `-`
-    /// where an infinity would render as `inf`.
-    #[test]
-    fn compression_ratio_guards_empty_volume() {
-        assert_eq!(volume(0, Some(0), Some(0)).compression_ratio(), None);
-        assert_eq!(volume(0, None, Some(200)).compression_ratio(), None);
-        assert_eq!(volume(0, Some(100), None).compression_ratio(), None);
-    }
-
-    fn pool(allocated: u64, reserved: u64, logical: Option<u64>) -> PoolUsage {
-        PoolUsage {
-            capacity: 1000,
-            allocated,
-            reserved,
-            logical,
-            metadata: None,
-        }
-    }
-
-    #[test]
-    fn free_is_capacity_minus_allocated() {
-        assert_eq!(pool(400, 0, None).free(), 600);
-        // A pool reporting more allocated than capacity must not wrap.
-        assert_eq!(pool(1200, 0, None).free(), 0);
-    }
-
-    /// Empty reservation is charged to the pool but has no logical
-    /// counterpart, so leaving it in the denominator understates
-    /// compression.
-    #[test]
-    fn pool_ratio_excludes_reservation() {
-        let p = pool(300, 100, Some(400));
-        assert_eq!(p.occupied(), 200);
-        assert_eq!(p.compression_ratio(), Some(2.0));
-    }
-
-    #[test]
-    fn pool_ratio_guards_fully_reserved_pool() {
-        assert_eq!(pool(100, 100, Some(0)).compression_ratio(), None);
-        assert_eq!(pool(0, 0, Some(0)).compression_ratio(), None);
-        assert_eq!(pool(100, 0, None).compression_ratio(), None);
-    }
-}
-
 /// Configuration for storage backend initialization during `ember init`.
 ///
 /// Carries the subset of init arguments that the storage backend needs.
@@ -690,3 +606,87 @@ pub trait Platform {
     /// callers are expected to soft-fail rather than block on this.
     fn host_ram_mib() -> anyhow::Result<u32>;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn volume(exclusive: u64, referenced: Option<u64>, logical: Option<u64>) -> VolumeUsage {
+        VolumeUsage {
+            provisioned: 1024,
+            exclusive,
+            referenced,
+            logical,
+        }
+    }
+
+    #[test]
+    fn shared_is_the_gap_between_referenced_and_exclusive() {
+        assert_eq!(volume(80, Some(100), None).shared(), Some(20));
+        assert_eq!(volume(100, Some(100), None).shared(), Some(0));
+    }
+
+    /// Backends that cannot separate shared from exclusive report
+    /// nothing rather than claiming zero sharing.
+    #[test]
+    fn shared_is_unknown_without_referenced() {
+        assert_eq!(volume(80, None, None).shared(), None);
+    }
+
+    /// `exclusive` is contractually within `referenced`, but the
+    /// saturating subtraction keeps a backend bug from producing a
+    /// wrapped, astronomically large shared figure.
+    #[test]
+    fn shared_saturates_instead_of_wrapping() {
+        assert_eq!(volume(120, Some(100), None).shared(), Some(0));
+    }
+
+    #[test]
+    fn compression_ratio_divides_logical_by_referenced() {
+        let r = volume(80, Some(100), Some(200)).compression_ratio();
+        assert_eq!(r, Some(2.0));
+    }
+
+    /// An untouched volume would divide by zero. `None` renders as `-`
+    /// where an infinity would render as `inf`.
+    #[test]
+    fn compression_ratio_guards_empty_volume() {
+        assert_eq!(volume(0, Some(0), Some(0)).compression_ratio(), None);
+        assert_eq!(volume(0, None, Some(200)).compression_ratio(), None);
+        assert_eq!(volume(0, Some(100), None).compression_ratio(), None);
+    }
+
+    fn pool(allocated: u64, reserved: u64, logical: Option<u64>) -> PoolUsage {
+        PoolUsage {
+            capacity: 1000,
+            allocated,
+            reserved,
+            logical,
+            metadata: None,
+        }
+    }
+
+    #[test]
+    fn free_is_capacity_minus_allocated() {
+        assert_eq!(pool(400, 0, None).free(), 600);
+        // A pool reporting more allocated than capacity must not wrap.
+        assert_eq!(pool(1200, 0, None).free(), 0);
+    }
+
+    /// Empty reservation is charged to the pool but has no logical
+    /// counterpart, so leaving it in the denominator understates
+    /// compression.
+    #[test]
+    fn pool_ratio_excludes_reservation() {
+        let p = pool(300, 100, Some(400));
+        assert_eq!(p.occupied(), 200);
+        assert_eq!(p.compression_ratio(), Some(2.0));
+    }
+
+    #[test]
+    fn pool_ratio_guards_fully_reserved_pool() {
+        assert_eq!(pool(100, 100, Some(0)).compression_ratio(), None);
+        assert_eq!(pool(0, 0, Some(0)).compression_ratio(), None);
+        assert_eq!(pool(100, 0, None).compression_ratio(), None);
+    }
+}