Initial

tests/integration_tests.rs

@@ -0,0 +1,259 @@
+use docker_compose_updater::compose::updater::ComposeUpdater;
+use docker_compose_updater::config::{Config, RegistryConfig, UpdateStrategy};
+use docker_compose_updater::registry::{Client, ImageRef};
+use std::collections::HashMap;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use tempfile::NamedTempFile;
+
+#[tokio::test]
+async fn test_end_to_end_compose_file_parsing_and_updating() {
+    let compose_content = r#"
+version: '3.8'
+services:
+  web:
+    image: nginx:1.21.0  # Web server
+    ports:
+      - "80:80"
+  
+  db:
+    image: postgres:13.7
+    environment:
+      POSTGRES_DB: myapp
+      
+  redis:
+    image: redis:6.2.1-alpine
+    ports:
+      - "6379:6379"
+"#;
+
+    let mut temp_file = NamedTempFile::new().unwrap();
+    temp_file.write_all(compose_content.as_bytes()).unwrap();
+
+    let config = create_test_config();
+    let updater = ComposeUpdater::new(config);
+
+    let result = updater
+        .parse_compose_file(temp_file.path().to_str().unwrap())
+        .unwrap();
+
+    assert_eq!(result.services.len(), 3);
+
+    assert_eq!(result.services[0].service_name, "web");
+    assert_eq!(result.services[0].image_ref.name, "nginx");
+    assert_eq!(result.services[0].image_ref.tag, "1.21.0");
+    assert_eq!(result.services[0].image_ref.registry, "docker.io");
+
+    assert_eq!(result.services[1].service_name, "db");
+    assert_eq!(result.services[1].image_ref.name, "postgres");
+    assert_eq!(result.services[1].image_ref.tag, "13.7");
+
+    assert_eq!(result.services[2].service_name, "redis");
+    assert_eq!(result.services[2].image_ref.name, "redis");
+    assert_eq!(result.services[2].image_ref.tag, "6.2.1-alpine");
+}
+
+#[tokio::test]
+async fn test_comment_and_formatting_preservation_during_updates() {
+    let compose_content = r#"
+version: '3.8'
+services:
+  web:
+    image: nginx:1.21.0  # This is a comment
+    ports:
+      - "80:80"
+  
+  # This is another comment
+  db:
+    image: "postgres:13.7"  # Database comment with quotes
+    environment:
+      POSTGRES_DB: myapp
+"#;
+
+    let mut temp_file = NamedTempFile::new().unwrap();
+    temp_file.write_all(compose_content.as_bytes()).unwrap();
+
+    let config = create_test_config();
+    let updater = ComposeUpdater::new(config);
+
+    let result = updater
+        .parse_compose_file(temp_file.path().to_str().unwrap())
+        .unwrap();
+
+    assert!(result.services[0]
+        .original_line
+        .contains("# This is a comment"));
+    assert!(result.services[1]
+        .original_line
+        .contains("# Database comment"));
+
+    let new_content = updater
+        .replace_image_in_content(&result.content, &result.services[0], "nginx:1.20.0")
+        .unwrap();
+
+    assert!(new_content.contains("# This is a comment"));
+    assert!(new_content.contains("nginx:1.20.0"));
+    assert!(!new_content.contains("nginx:1.21.0"));
+
+    let new_content = updater
+        .replace_image_in_content(&new_content, &result.services[1], "postgres:14.0")
+        .unwrap();
+
+    assert!(new_content.contains("# Database comment"));
+    assert!(new_content.contains("\"postgres:14.0\""));
+    assert!(!new_content.contains("postgres:13.7"));
+}
+
+#[tokio::test]
+async fn test_empty_compose_paths_handling() {
+    let config = Config {
+        compose_paths: vec![],
+        ..create_test_config()
+    };
+    let updater = ComposeUpdater::new(config);
+
+    let result = updater.update_all_compose_files().await;
+    assert!(result.is_ok());
+    assert!(result.unwrap().is_empty());
+}
+
+#[test]
+fn test_config_defaults_and_image_filtering() {
+    let config = Config::default();
+
+    assert_eq!(config.schedule, "0 0 2 * * *");
+    assert_eq!(
+        config.update_strategy,
+        UpdateStrategy::LatestPatchOfPreviousMinor
+    );
+    assert!(!config.dry_run);
+    assert!(config.registries.contains_key("docker.io"));
+    assert!(config.registries.contains_key("ghcr.io"));
+
+    let config_with_ignores = Config {
+        ignore_images: vec!["localhost".to_string(), "127.0.0.1".to_string()],
+        ..Config::default()
+    };
+
+    assert!(config_with_ignores.is_image_ignored("localhost:5000/myapp:latest"));
+    assert!(config_with_ignores.is_image_ignored("127.0.0.1:5000/myapp:latest"));
+    assert!(!config_with_ignores.is_image_ignored("nginx:1.21.0"));
+}
+
+fn create_test_config() -> Config {
+    let mut registries = HashMap::new();
+    registries.insert(
+        "docker.io".to_string(),
+        RegistryConfig {
+            url: "https://registry-1.docker.io".to_string(),
+            auth_token: None,
+        },
+    );
+
+    Config {
+        compose_paths: vec![PathBuf::from("./test")],
+        schedule: "0 0 2 * * *".to_string(),
+        registries,
+        update_strategy: UpdateStrategy::LatestPatchOfPreviousMinor,
+        ignore_images: vec!["localhost".to_string()],
+        dry_run: true,
+    }
+}
+
+#[test]
+fn test_env_var_substitution() {
+    // Test environment variable substitution in config
+    std::env::set_var("TEST_TOKEN", "test_value_123");
+
+    let test_yaml = r#"
+registries:
+  "test.registry":
+    url: "https://test.registry"
+    auth_token: "${TEST_TOKEN}"
+"#;
+
+    let expanded = Config::expand_env_vars(test_yaml);
+    assert!(expanded.contains("test_value_123"));
+    assert!(!expanded.contains("${TEST_TOKEN}"));
+
+    // Clean up
+    std::env::remove_var("TEST_TOKEN");
+}
+
+#[test]
+fn test_config_loading_with_env_vars() {
+    // Set up test environment variable
+    std::env::set_var("GITHUB_TOKEN", "ghp_test_token_for_testing");
+
+    // Test that config loading works with our test config
+    if std::path::Path::new("config.test.yaml").exists() {
+        let config = Config::load(Path::new("config.test.yaml").to_path_buf()).unwrap();
+
+        if let Some(ghcr_config) = config.registries.get("ghcr.io") {
+            // Should have resolved the environment variable
+            assert_eq!(
+                ghcr_config.auth_token,
+                Some("ghp_test_token_for_testing".to_string())
+            );
+        }
+    }
+
+    // Clean up
+    std::env::remove_var("GITHUB_TOKEN");
+}
+
+#[tokio::test]
+#[ignore = "Only run in CI with GITHUB_TOKEN set"]
+async fn test_ghcr_authentication_e2e() {
+    let github_token = std::env::var("GITHUB_TOKEN").unwrap();
+
+    // This test validates that Docker Registry v2 authentication works with GHCR
+    let mut registries = HashMap::new();
+    registries.insert(
+        "docker.io".to_string(),
+        RegistryConfig {
+            url: "https://registry-1.docker.io".to_string(),
+            auth_token: None,
+        },
+    );
+    registries.insert(
+        "ghcr.io".to_string(),
+        RegistryConfig {
+            url: "https://ghcr.io".to_string(),
+            // Use the token we validated above
+            auth_token: Some(github_token),
+        },
+    );
+
+    let config = Config {
+        compose_paths: vec![PathBuf::from("./test")],
+        schedule: "0 0 2 * * *".to_string(),
+        registries,
+        update_strategy: UpdateStrategy::LatestPatchOfPreviousMinor,
+        ignore_images: vec!["localhost".to_string()],
+        dry_run: true,
+    };
+
+    let client = Client::new(config);
+
+    // Test with the actual image that was failing
+    let image_ref = ImageRef::parse("ghcr.io/schmelczer/vault-link:0.5.1").unwrap();
+
+    let result = client.get_available_versions(&image_ref).await;
+
+    match result {
+        Ok(versions) => {
+            assert!(!versions.is_empty(), "Should return at least one version");
+
+            // Verify that we can find the specific version 0.5.1
+            let has_target_version = versions.iter().any(|v| v.version.to_string() == "0.5.1");
+            assert!(
+                has_target_version,
+                "Should find target version 0.5.1 in available versions"
+            );
+        }
+        Err(e) => {
+            panic!("GHCR authentication test failed: {e}");
+        }
+    }
+}