feat: implement test_trunk_based_development_flow

wislertt · wislertt · commit da70a0ab6123 · 2025-10-30T23:17:56.000+07:00
diff --git a/.claude/plan/34-zerv-flow-implementation-steps.md b/.claude/plan/34-zerv-flow-implementation-steps.md
@@ -1,10 +1,10 @@
 # Zerv Flow Implementation Plan
 
-**Status**: In Progress
+**Status**: Phase 2 Complete
 **Priority**: High
 **Context**: Step-by-step implementation plan for the `zerv flow` command based on CLI design in document #33.
 
-## Current Progress Summary (as of Oct 29, 2025)
+## Current Progress Summary (as of Oct 30, 2025)
 
 ### ✅ **Completed Work:**
 
@@ -22,17 +22,32 @@
     - Eliminated code duplication between commands
     - Comprehensive test coverage (35 tests) for shared components
 
-- **Code Quality Improvements**: Completed
+- **Code Quality Improvements**: Completed ✅
     - Added BoolResolution utility for opposing boolean flags
     - Cleaned up verbose documentation comments
     - Fixed inconsistent module structures
     - Added comprehensive test coverage to common args
 
+- **Phase 2**: Flow Logic as Translation Layer - 100% Complete ✅
+    - **Step 4**: Basic Flow Pipeline Implementation ✅
+    - Successfully integrates with existing `zerv version` command
+    - RON output parsing to Zerv object working correctly
+    - `OutputFormatter::format_output()` integration complete
+    - Translation layer approach proven successful
+
+- **Test Infrastructure**: Completed ✅
+    - Pattern assertion utilities in `src/test_utils/pattern_assertions.rs`
+    - Enhanced GitRepoFixture with branch and dirty operations:
+        - `with_distance_and_branch(tag, commits, branch)`
+        - `checkout_branch(branch)`
+        - `make_dirty()`
+    - Step-by-step git flow testing with comprehensive validation
+    - All tests passing (10+ assertion tests, 9 fixture tests, 1 flow test)
+
 ### 🔄 **Next Steps:**
 
-- **Phase 2**: Implement basic flow pipeline structure with version command integration (IN PROGRESS)
-- **Phase 3**: Add branch pattern system and flow-to-version translation logic
-- **Phase 4**: Complete pipeline assembly and comprehensive testing
+- **Phase 3**: Add branch pattern system and flow-to-version translation logic (PENDING)
+- **Phase 4**: Complete pipeline assembly and comprehensive testing (PENDING)
 
 ## Goals
 
diff --git a/src/cli/flow/pipeline.rs b/src/cli/flow/pipeline.rs
@@ -1,15 +1,11 @@
 use ron::from_str;
 
-use crate::cli::common::args::{
-    InputConfig,
-    OutputConfig,
-};
+use crate::cli::common::args::OutputConfig;
 use crate::cli::flow::args::FlowArgs;
 use crate::cli::utils::output_formatter::OutputFormatter;
 use crate::cli::version::args::VersionArgs;
 use crate::cli::version::pipeline::run_version_pipeline;
 use crate::error::ZervError;
-use crate::utils::constants::*;
 
 /// Main flow pipeline handler
 ///
@@ -28,11 +24,7 @@ pub fn run_flow_pipeline(args: FlowArgs) -> Result<String, ZervError> {
     // For now, just call version command with zerv output format
     // TODO: Phase 2+ - Translate flow arguments to version arguments
     let version_args = VersionArgs {
-        input: InputConfig {
-            source: sources::GIT.to_string(),
-            input_format: "auto".to_string(),
-            directory: None,
-        },
+        input: args.input.clone(),
         output: OutputConfig {
             output_format: "zerv".to_string(),
             output_template: None,
@@ -64,66 +56,74 @@ pub fn run_flow_pipeline(args: FlowArgs) -> Result<String, ZervError> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::test_utils::{
+        GitRepoFixture,
+        assert_version_expectation,
+        should_run_docker_tests,
+    };
 
-    #[test]
-    fn test_run_flow_pipeline_basic() {
-        let args = FlowArgs::default();
-        let result = run_flow_pipeline(args);
-        // Should work now (assuming git repo exists)
-        // Note: This test may fail in environments without git
-        match result {
-            Ok(_) => {} // Success
-            Err(ZervError::VcsNotFound(_)) => {
-                // Expected in test environments without git
-            }
-            Err(e) => {
-                panic!("Unexpected error: {:?}", e);
-            }
-        }
-    }
-
-    #[test]
-    fn test_run_flow_pipeline_different_output_formats() {
-        let formats = ["semver", "pep440", "zerv"];
+    fn test_flow_pipeline_with_fixture(
+        fixture_path: &str,
+        semver_expectation: &str,
+        pep440_expectation: &str,
+    ) {
+        let test_cases = vec![
+            ("semver", semver_expectation),
+            ("pep440", pep440_expectation),
+        ];
 
-        for format in formats.iter() {
+        for (format_name, expectation) in test_cases {
             let mut args = FlowArgs::default();
-            args.output.output_format = format.to_string();
+            args.input.directory = Some(fixture_path.to_string());
+            args.output.output_format = format_name.to_string();
 
             let result = run_flow_pipeline(args);
-            match result {
-                Ok(_) => {} // Success
-                Err(ZervError::VcsNotFound(_)) => {
-                    // Expected in test environments without git
-                }
-                Err(e) => {
-                    panic!("Unexpected error for format '{}': {:?}", format, e);
-                }
-            }
+            assert!(
+                result.is_ok(),
+                "Flow pipeline should succeed with {} format at {}",
+                format_name,
+                fixture_path
+            );
+            let output = result.unwrap();
+            assert!(
+                !output.is_empty(),
+                "Flow pipeline should produce output for {} format",
+                format_name
+            );
+
+            assert_version_expectation(expectation, &output);
+
+            println!("✓ Flow pipeline output ({}): {}", format_name, output);
         }
     }
 
     #[test]
-    fn test_run_flow_pipeline_with_output_prefix() {
-        let mut args = FlowArgs::default();
-        args.output.output_prefix = Some("v".to_string());
-
-        let result = run_flow_pipeline(args);
-        match result {
-            Ok(output) => {
-                // Output should start with the prefix
-                assert!(
-                    output.starts_with('v'),
-                    "Output should start with prefix 'v': {}",
-                    output
-                );
-            }
-            Err(ZervError::VcsNotFound(_)) => {
-                // Expected in test environments without git
-            }
-            Err(e) => {
-                panic!("Unexpected error: {:?}", e);
-            }
+    fn test_trunk_based_development_flow() {
+        if !should_run_docker_tests() {
+            return; // Skip when `ZERV_TEST_DOCKER` are disabled
         }
+
+        // Step 1: Start with a clean tag
+        let fixture =
+            GitRepoFixture::tagged("v1.0.0").expect("Failed to create git fixture with tag");
+        let fixture_path = fixture.path().to_string_lossy();
+
+        test_flow_pipeline_with_fixture(&fixture_path, r"1.0.0", r"1.0.0");
+
+        // Step 2: Checkout feature branch
+        fixture
+            .checkout_branch("feature-1")
+            .expect("Failed to checkout feature-1 branch");
+
+        test_flow_pipeline_with_fixture(&fixture_path, r"1.0.0", r"1.0.0");
+
+        // Step 3: Make dirty working directory
+        fixture.make_dirty().expect("Failed to make fixture dirty");
+
+        test_flow_pipeline_with_fixture(
+            &fixture_path,
+            r"1.0.0+feature.1.0.{{commit_hash_7}}",
+            r"1.0.0+feature.1.0.{{commit_hash_7}}",
+        );
     }
 }
diff --git a/src/test_utils/git/fixtures.rs b/src/test_utils/git/fixtures.rs
@@ -58,6 +58,21 @@ impl GitRepoFixture {
         Ok(fixture)
     }
 
+    /// Checkout to an existing or new branch
+    pub fn checkout_branch(&self, branch: &str) -> Result<(), Box<dyn std::error::Error>> {
+        self.git_impl
+            .create_branch(&self.test_dir, branch)
+            .map_err(|e| format!("Failed to checkout branch '{}': {e}", branch))?;
+        Ok(())
+    }
+
+    /// Make the working directory dirty with uncommitted changes
+    pub fn make_dirty(&self) -> Result<(), Box<dyn std::error::Error>> {
+        self.test_dir
+            .create_file("dirty_file.txt", "dirty content")?;
+        Ok(())
+    }
+
     /// Create a repository with dirty working directory (Tier 3: major.minor.patch.dev<timestamp>+branch.<commit>)
     pub fn dirty(tag: &str) -> Result<Self, Box<dyn std::error::Error>> {
         let fixture = Self::tagged(tag)?;
@@ -85,6 +100,51 @@ mod tests {
     use super::*;
     use crate::test_utils::should_run_docker_tests;
 
+    #[test]
+    #[serial(fixture_methods)]
+    fn test_checkout_branch() {
+        if !should_run_docker_tests() {
+            return;
+        }
+
+        let fixture = GitRepoFixture::tagged("v1.0.0").expect("Failed to create fixture with tag");
+
+        // Checkout a new branch
+        fixture
+            .checkout_branch("feature-test")
+            .expect("Failed to checkout feature-test branch");
+
+        // Verify branch was created
+        let current_branch = fixture
+            .git_impl
+            .execute_git(&fixture.test_dir, &["branch", "--show-current"])
+            .expect("Failed to get current branch");
+        assert_eq!(current_branch.trim(), "feature-test");
+    }
+
+    #[test]
+    #[serial(fixture_methods)]
+    fn test_make_dirty() {
+        if !should_run_docker_tests() {
+            return;
+        }
+
+        let fixture = GitRepoFixture::tagged("v1.0.0").expect("Failed to create fixture with tag");
+
+        // Make the working directory dirty
+        fixture.make_dirty().expect("Failed to make fixture dirty");
+
+        // Verify the dirty file exists
+        assert!(fixture.path().join("dirty_file.txt").exists());
+
+        // Verify git status shows uncommitted changes
+        let status = fixture
+            .git_impl
+            .execute_git(&fixture.test_dir, &["status", "--porcelain"])
+            .expect("Failed to get git status");
+        assert!(status.contains("dirty_file.txt"));
+    }
+
     static SHARED_V1_FIXTURE: Mutex<Option<(std::path::PathBuf, tempfile::TempDir)>> =
         Mutex::new(None);
 
diff --git a/src/test_utils/mod.rs b/src/test_utils/mod.rs
@@ -1,6 +1,7 @@
 pub mod dir;
 pub mod git;
 pub mod output;
+pub mod pattern_assertions;
 pub mod types;
 pub mod vcs_fixtures;
 pub mod version_args;
@@ -14,6 +15,7 @@ pub use git::{
     NativeGit,
 };
 pub use output::TestOutput;
+pub use pattern_assertions::assert_version_expectation;
 pub use types::{
     BumpType,
     OverrideType,
diff --git a/src/test_utils/pattern_assertions.rs b/src/test_utils/pattern_assertions.rs
