feat: implement integration tests for sources args

Author: wislertt

.dev/27-integration-tests-revamp-plan.md

@@ -131,18 +131,25 @@ tests/integration_tests/version/
     - Directory structure created successfully
     - Ready for Phase 2 implementation
 
-#### Phase 2: Implement Main Config Tests (`main/`)
-
-- Create `tests/integration_tests/version/main/mod.rs`
-- Implement individual MainConfig tests:
-    - `sources/`: git vs stdin (≤3 git tests)
-    - `formats.rs`: --input-format, --output-format individually
-    - `schemas.rs`: --schema, --schema-ron individually
-    - `templates.rs`: --output-template individually
-    - `directory.rs`: -C flag individually
-    - `combinations.rs`: MainConfig option combinations
-- Use direct imports: `use zerv::test_utils::{ZervFixture, GitRepoFixture};`
-- Test and validate main config functionality
+#### Phase 2: Implement Main Config Tests (`main/`) 🔄 IN PROGRESS
+
+- ✅ Created `tests/integration_tests/version/main/mod.rs`
+- ✅ Implemented `sources/` tests:
+    - `sources/stdin.rs`: 6 stdin tests using `ZervFixture` with `TestCommand.stdin()` (✅ PASSED)
+    - `sources/git.rs`: 1 comprehensive git integration test with Docker gating (✅ PASSED)
+- ✅ Enhanced `TestCommand` with `.stdin()` support for cleaner testing
+- ✅ Refactored tests to use `rstest` for cleaner parameterized testing
+- ✅ Enhanced `ZervFixture.with_vcs_data()` to accept `Option` types for better flexibility
+- **Result**: 7 tests passing (100% success rate)
+- **Performance**: Tests run in <0.3 seconds without Docker
+
+**Remaining MainConfig Tests:**
+
+- ❌ `formats.rs`: Test `--input-format` (semver/pep440/zerv) and `--output-format` (semver/pep440/zerv) combinations
+- ❌ `schemas.rs`: Test `--schema` (tier1/tier2/tier3) and `--schema-ron` (custom RON schema) options
+- ❌ `templates.rs`: Test `--output-template` with Handlebars template rendering
+- ❌ `directory.rs`: Test `-C` flag for changing working directory before execution
+- ❌ `combinations.rs`: Test MainConfig option combinations (format + schema, template + format, etc.)
 
 #### Phase 3: Implement Override Tests (`overrides/`)
 

CLAUDE.md

@@ -0,0 +1,254 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+Zerv is a dynamic versioning CLI tool written in Rust that generates versions for any commit from git and other version control systems. It supports multiple version formats (SemVer, PEP440, CalVer) and is designed for CI/CD builds.
+
+## Essential Commands
+
+### Development Setup
+
+```bash
+make setup_dev  # Install pre-commit hooks and cargo-tarpaulin
+```
+
+### Testing
+
+```bash
+make test_easy  # Quick tests: Docker Git + Docker tests skipped (fast, coverage gaps)
+make test       # Full test suite: Docker Git + Docker tests enabled (full coverage)
+make test_flaky # Run 5 iterations to detect flaky tests
+```
+
+### Building and Running
+
+```bash
+make run        # Run the CLI with cargo run
+cargo build     # Build debug version
+cargo build --release  # Build optimized release version
+```
+
+### Code Quality
+
+```bash
+make lint       # Check code formatting and clippy warnings
+make update     # Update Rust toolchain and dependencies
+```
+
+### Coverage
+
+```bash
+make test              # Generates coverage reports
+make open_coverage     # Open HTML coverage report
+```
+
+### Documentation
+
+```bash
+make docs       # Generate documentation via cargo xtask
+```
+
+## High-Level Architecture
+
+### Pipeline Architecture
+
+The core processing follows a clear pipeline pattern:
+
+```
+Input → VCS Detection → Version Parsing → Transformation → Format Output
+```
+
+**Key Modules:**
+
+- **`src/vcs/`**: Version Control System abstraction (currently Git only)
+    - Detects VCS repositories and extracts metadata
+    - `VcsData` struct contains tag versions, distance, commits, branches, timestamps
+
+- **`src/version/`**: Version format implementations
+    - `VersionObject`: Universal internal representation
+    - `PEP440`: Python versioning standard
+    - `SemVer`: Semantic versioning
+    - `Zerv`: Custom component-based format with variable references
+
+- **`src/pipeline/`**: Data transformation layer
+    - `parse_version_from_tag()`: Extracts version from git tags
+    - `vcs_data_to_zerv_vars()`: Converts VCS metadata to Zerv variables
+
+- **`src/schema/`**: Schema and preset management
+    - Presets for common versioning schemes (standard, calver)
+    - RON-based schema parsing for custom formats
+
+- **`src/cli/`**: Command-line interface (in development)
+    - Main commands: `version`, `check`
+    - Output formatting and display logic
+
+### State-Based Versioning Tiers
+
+Zerv uses a three-tier system based on repository state:
+
+- **Tier 1** (Tagged, clean): `major.minor.patch`
+- **Tier 2** (Distance, clean): `major.minor.patch.post<distance>+branch.<commit>`
+- **Tier 3** (Dirty): `major.minor.patch.dev<timestamp>+branch.<commit>`
+
+### Test Infrastructure
+
+The project has extensive test utilities in `src/test_utils/`:
+
+- **Environment-aware Git testing**: Uses `DockerGit` locally, `NativeGit` in CI
+- **`GitOperations` trait**: Unified interface for both implementations
+- **`GitRepoFixture`**: Creates isolated test repositories with specific states
+- **`TestDir`**: Temporary directory management with automatic cleanup
+
+## Testing Standards
+
+### Environment Variables
+
+- `ZERV_TEST_NATIVE_GIT=true`: Use native Git (set in CI for platform testing)
+- `ZERV_TEST_DOCKER=true`: Enable Docker-dependent tests (requires Docker)
+
+### Git Testing Pattern
+
+ALWAYS use the environment-aware pattern:
+
+```rust
+use crate::test_utils::{GitOperations, get_git_impl};
+
+let git_impl = get_git_impl(); // Returns DockerGit or NativeGit based on environment
+git_impl.init_repo(&test_dir)?;
+```
+
+### Docker Test Gating
+
+For Docker-dependent tests:
+
+```rust
+use crate::test_utils::should_run_docker_tests;
+
+#[test]
+fn test_docker_functionality() {
+    if !should_run_docker_tests() {
+        return; // Skip when Docker tests are disabled
+    }
+    // Test code here
+}
+```
+
+### Flaky Test Prevention
+
+- Use `GitOperations` trait methods for atomic operations
+- Create fresh Git implementations for each test directory
+- Include detailed error messages with context
+- Verify intermediate states (e.g., `.git` directory exists)
+- Never reuse Git implementations across different directories
+
+## Coding Standards
+
+### Error Handling
+
+- **ALWAYS** use `zerv::error::ZervError` for custom errors
+- Use `io::Error::other()` instead of `io::Error::new(io::ErrorKind::Other, ...)`
+- Include context in error messages for debugging
+- Proper error propagation with `?` operator
+
+### Constants Usage
+
+**MANDATORY**: Always use constants instead of bare strings:
+
+```rust
+// GOOD
+use crate::utils::constants::{fields, formats, sources, schema_names};
+match field_name.as_str() {
+    fields::MAJOR => // ...
+    fields::MINOR => // ...
+}
+
+// BAD - Never use bare strings
+match field_name.as_str() {
+    "major" => // ...
+}
+```
+
+### Code Reuse
+
+Before implementing new test utilities:
+
+- Check `src/test_utils/` for existing infrastructure
+- Reuse `TestDir`, `GitOperations` trait, and other helpers
+- Use `get_git_impl()` for environment-aware Git operations
+- Avoid duplicating code across files
+
+### Performance Standards
+
+- Parse 1000+ versions in <100ms
+- Minimal VCS command calls (batch when possible)
+- Use compiled regex patterns for speed
+- Zero-copy string operations where possible
+
+## CI/CD
+
+### Multi-Platform Testing
+
+- **Linux**: Native Git + Docker tests enabled
+- **macOS**: Native Git + Docker tests skipped
+- **Windows**: Native Git + Docker tests skipped
+
+### Pre-commit Hooks
+
+The project uses pre-commit hooks for:
+
+- Code formatting (rustfmt)
+- Linting (clippy)
+- Running tests
+
+### GitHub Actions
+
+Main workflows:
+
+- `ci-test.yml`: Runs tests across Linux, macOS, Windows
+- `ci-pre-commit.yml`: Validates formatting and linting
+- `cd.yml`: Release automation
+- `security.yml`: Security scanning with SonarCloud
+
+## Important Files
+
+### Development Documentation
+
+Read `.dev/00-README.md` FIRST before any coding task. All `.dev/` documents use sequential numbering (00, 01, 02...) where higher numbers indicate more recent plans.
+
+### Cursor Rules (Apply to Claude Code)
+
+Key rules in `.cursor/rules/`:
+
+- `dev-workflow.mdc`: Development workflow and git practices
+- `testing-standards.mdc`: Comprehensive testing requirements
+- `cli-implementation.mdc`: CLI standards and patterns
+- `docker-git-testing.mdc`: Docker testing architecture
+
+## Running Tests for Specific Features
+
+```bash
+# Run all tests
+cargo test
+
+# Run git-related tests
+cargo test git
+
+# Run specific test file
+cargo test --test integration_test_name
+
+# Run with features
+cargo test --features test-utils
+
+# Run a single test
+cargo test test_name -- --exact
+```
+
+## Configuration
+
+Centralized config in `src/config.rs`:
+
+- Loads environment variables (`ZERV_TEST_NATIVE_GIT`, `ZERV_TEST_DOCKER`)
+- Validates boolean parsing
+- Single source of truth for environment configuration

Cargo.lock

@@ -46,5 +46,6 @@ tempfile = { version = "^3.0", optional = true }
 [dev-dependencies]
 rstest = "^0.26.0"
 serial_test = "^3.0"
+shlex = "^1.3"
 tempfile = "^3.0"
 zerv = { path = ".", features = ["test-utils"] }

Cargo.toml

@@ -91,13 +91,13 @@ mod tests {
 
     fn vcs_zerv() -> ZervFixture {
         ZervFixture::new().with_version(1, 2, 3).with_vcs_data(
-            0,
-            true,
-            "main".to_string(),
-            "abcdef123456".to_string(),
-            "xyz789".to_string(),
-            1234567890,
-            "main".to_string(),
+            Some(0),
+            Some(true),
+            Some("main".to_string()),
+            Some("abcdef123456".to_string()),
+            Some("xyz789".to_string()),
+            Some(1234567890),
+            Some("main".to_string()),
         )
     }
 

src/cli/utils/template/context.rs

@@ -105,21 +105,21 @@ impl ZervVarsFixture {
     #[allow(clippy::too_many_arguments)]
     pub fn with_vcs_data(
         mut self,
-        distance: u64,
-        dirty: bool,
-        bumped_branch: String,
-        bumped_commit_hash: String,
-        last_commit_hash: String,
-        last_timestamp: u64,
-        last_branch: String,
+        distance: Option<u64>,
+        dirty: Option<bool>,
+        bumped_branch: Option<String>,
+        bumped_commit_hash: Option<String>,
+        last_commit_hash: Option<String>,
+        last_timestamp: Option<u64>,
+        last_branch: Option<String>,
     ) -> Self {
-        self.vars.distance = Some(distance);
-        self.vars.dirty = Some(dirty);
-        self.vars.bumped_branch = Some(bumped_branch);
-        self.vars.bumped_commit_hash = Some(bumped_commit_hash);
-        self.vars.last_commit_hash = Some(last_commit_hash);
-        self.vars.last_timestamp = Some(last_timestamp);
-        self.vars.last_branch = Some(last_branch);
+        self.vars.distance = distance;
+        self.vars.dirty = dirty;
+        self.vars.bumped_branch = bumped_branch;
+        self.vars.bumped_commit_hash = bumped_commit_hash;
+        self.vars.last_commit_hash = last_commit_hash;
+        self.vars.last_timestamp = last_timestamp;
+        self.vars.last_branch = last_branch;
         self
     }