test+ci: unit-test phase_for and add CI workflow

Move phase_for from main.rs into lib.rs as first-class domain logic —
it is the core of the operator (mapping ready replicas to the
Pending/Warming/Ready lifecycle that encodes "warm, not merely running"),
not a main-local helper. main.rs now imports it.

Add five unit tests covering the phase transitions and edge cases:
zero ready -> Pending, partial -> Warming, all ready -> Ready, the
scale-to-one case, and the brief scale-down state where ready exceeds
desired (still a serving state).

Add a CI workflow (fmt --check, clippy, test, release build) with
RUSTFLAGS=-D warnings enforced workflow-wide, matching the pre-push
discipline used across the other repos. An end-to-end job that exercises
the controller against an ephemeral kind cluster will follow.

Author: MicheleCampi

.github/workflows/ci.yml

@@ -0,0 +1,44 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+  RUSTFLAGS: "-D warnings"
+
+jobs:
+  check:
+    name: fmt + clippy + test + build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+
+      - name: Cache cargo registry and target
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Format check
+        run: cargo fmt --all --check
+
+      - name: Clippy
+        run: cargo clippy --workspace --all-targets
+
+      - name: Test
+        run: cargo test --workspace
+
+      - name: Build release
+        run: cargo build --release

src/lib.rs

@@ -52,3 +52,68 @@ pub struct VllmServiceStatus {
     /// Human-readable detail about the current phase.
     pub message: String,
 }
+
+/// Lifecycle phase derived from the owned Deployment's ready replicas.
+///
+/// This is the heart of the operator: a vLLM pod that Kubernetes considers
+/// "Running" is not yet able to serve a token — it still has to load weights
+/// and warm up. The cold-start study quantified that gap; here it becomes an
+/// observable phase. "Ready" means warm, not merely alive.
+pub fn phase_for(desired: i32, ready: i32) -> (&'static str, String) {
+    if ready == 0 {
+        (
+            "Pending",
+            "Deployment created; no replica ready yet".to_string(),
+        )
+    } else if ready < desired {
+        (
+            "Warming",
+            format!("{ready}/{desired} replicas ready; warming up"),
+        )
+    } else {
+        (
+            "Ready",
+            format!("{ready}/{desired} replicas ready and warm"),
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn zero_ready_is_pending() {
+        let (phase, _) = phase_for(3, 0);
+        assert_eq!(phase, "Pending");
+    }
+
+    #[test]
+    fn partial_ready_is_warming() {
+        let (phase, msg) = phase_for(3, 1);
+        assert_eq!(phase, "Warming");
+        assert!(msg.contains("1/3"));
+    }
+
+    #[test]
+    fn all_ready_is_ready() {
+        let (phase, msg) = phase_for(3, 3);
+        assert_eq!(phase, "Ready");
+        assert!(msg.contains("3/3"));
+    }
+
+    #[test]
+    fn single_replica_ready() {
+        // The common scale-to-one case: one desired, one ready -> Ready.
+        let (phase, _) = phase_for(1, 1);
+        assert_eq!(phase, "Ready");
+    }
+
+    #[test]
+    fn ready_exceeding_desired_is_still_ready() {
+        // During a scale-down a Deployment can briefly report more ready
+        // than desired; that is still a serving state, not a warming one.
+        let (phase, _) = phase_for(2, 3);
+        assert_eq!(phase, "Ready");
+    }
+}

src/main.rs

@@ -18,7 +18,7 @@ use serde_json::json;
 use thiserror::Error;
 use tracing::{info, warn};
 
-use vllm_coldstart_operator::{VllmService, VllmServiceStatus, WarmupStrategy};
+use vllm_coldstart_operator::{phase_for, VllmService, VllmServiceStatus, WarmupStrategy};
 
 const MANAGER: &str = "vllm-coldstart-operator";
 
@@ -34,32 +34,6 @@ struct Context {
     client: Client,
 }
 
-/// Lifecycle phase derived from the owned Deployment's ready replicas.
-///
-/// This is the heart of the operator: a vLLM pod that is "Running" from
-/// Kubernetes' point of view is not yet able to serve a token — it still
-/// has to load weights and warm up. The cold-start study quantified that
-/// gap; here it becomes an observable phase. "Ready" means warm, not just
-/// alive.
-fn phase_for(desired: i32, ready: i32) -> (&'static str, String) {
-    if ready == 0 {
-        (
-            "Pending",
-            "Deployment created; no replica ready yet".to_string(),
-        )
-    } else if ready < desired {
-        (
-            "Warming",
-            format!("{ready}/{desired} replicas ready; warming up"),
-        )
-    } else {
-        (
-            "Ready",
-            format!("{ready}/{desired} replicas ready and warm"),
-        )
-    }
-}
-
 fn build_deployment(svc: &VllmService) -> Result<Deployment, Error> {
     let name = svc.name_any();
     let ns = svc.namespace().ok_or(Error::MissingNamespace)?;