forjar 1.4.1

//! FJ-216: Parallel resource execution tests, FJ-224: Trigger tests.

use super::*;

// ================================================================
// FJ-216: parallel resource execution tests
// ================================================================

#[test]
fn test_fj216_compute_resource_waves_no_deps() {
    let yaml = r#"
version: "1.0"
name: test
machines:
  m1:
    hostname: m1
    addr: 1.2.3.4
resources:
  a:
    type: file
    machine: m1
    path: /a
  b:
    type: file
    machine: m1
    path: /b
"#;
    let config: ForjarConfig = serde_yaml_ng::from_str(yaml).unwrap();
    let waves = compute_resource_waves(&config, &["a", "b"]);
    assert_eq!(waves.len(), 1);
    assert_eq!(waves[0].len(), 2);
}

#[test]
fn test_fj216_compute_resource_waves_with_deps() {
    let yaml = r#"
version: "1.0"
name: test
machines:
  m1:
    hostname: m1
    addr: 1.2.3.4
resources:
  base:
    type: file
    machine: m1
    path: /base
  app:
    type: file
    machine: m1
    path: /app
    depends_on: [base]
"#;
    let config: ForjarConfig = serde_yaml_ng::from_str(yaml).unwrap();
    let waves = compute_resource_waves(&config, &["base", "app"]);
    assert_eq!(waves.len(), 2);
    assert_eq!(waves[0], vec!["base"]);
    assert_eq!(waves[1], vec!["app"]);
}

#[test]
fn test_fj216_compute_resource_waves_subset() {
    let yaml = r#"
version: "1.0"
name: test
machines:
  m1:
    hostname: m1
    addr: 1.2.3.4
resources:
  a:
    type: file
    machine: m1
    path: /a
  b:
    type: file
    machine: m1
    path: /b
    depends_on: [a]
  c:
    type: file
    machine: m1
    path: /c
"#;
    let config: ForjarConfig = serde_yaml_ng::from_str(yaml).unwrap();
    // Only compute waves for b and c (b depends on a which is outside subset)
    let waves = compute_resource_waves(&config, &["b", "c"]);
    // Both should be in wave 0 since a is not in subset
    assert_eq!(waves.len(), 1);
    assert_eq!(waves[0].len(), 2);
}

#[test]
fn test_fj216_parallel_resources_policy_default_false() {
    let policy = Policy::default();
    assert!(!policy.parallel_resources);
}

#[test]
fn test_fj216_parallel_resources_policy_yaml() {
    let yaml = r#"
version: "1.0"
name: test
machines:
  m1:
    hostname: m1
    addr: 1.2.3.4
resources: {}
policy:
  parallel_resources: true
"#;
    let config: ForjarConfig = serde_yaml_ng::from_str(yaml).unwrap();
    assert!(config.policy.parallel_resources);
}

#[test]
fn test_fj224_trigger_forces_reapply() {
    // First apply: both config and app converge
    let dir = tempfile::tempdir().unwrap();
    let state_dir = dir.path().join("state");
    std::fs::create_dir_all(&state_dir).unwrap();

    let yaml = r#"
version: "1.0"
name: test
machines:
  local:
    hostname: localhost
    addr: 127.0.0.1
resources:
  config:
    type: file
    machine: local
    path: /tmp/fj224-config.txt
    content: "v1"
  app:
    type: file
    machine: local
    path: /tmp/fj224-app.txt
    content: "app-content"
    depends_on: [config]
    triggers: [config]
"#;
    let config: ForjarConfig = serde_yaml_ng::from_str(yaml).unwrap();
    let cfg1 = ApplyConfig {
        config: &config,
        state_dir: &state_dir,
        force: false,
        dry_run: false,
        machine_filter: None,
        resource_filter: None,
        tag_filter: None,
        group_filter: None,
        timeout_secs: None,
        force_unlock: false,
        progress: false,
        retry: 0,
        parallel: None,
        resource_timeout: None,
        rollback_on_failure: false,
        max_parallel: None,
        trace: false,
        run_id: None,
        refresh: false,
        force_tag: None,
    };
    let r1 = apply(&cfg1).unwrap();
    assert_eq!(r1[0].resources_converged, 2);

    // Second apply, same config: both should be NoOp (unchanged)
    let r2 = apply(&cfg1).unwrap();
    assert_eq!(r2[0].resources_converged, 0, "no changes = no converge");
    assert_eq!(r2[0].resources_unchanged, 2);

    // Third apply: change config content → config converges → app should be triggered
    let yaml3 = r#"
version: "1.0"
name: test
machines:
  local:
    hostname: localhost
    addr: 127.0.0.1
resources:
  config:
    type: file
    machine: local
    path: /tmp/fj224-config.txt
    content: "v2"
  app:
    type: file
    machine: local
    path: /tmp/fj224-app.txt
    content: "app-content"
    depends_on: [config]
    triggers: [config]
"#;
    let config3: ForjarConfig = serde_yaml_ng::from_str(yaml3).unwrap();
    let cfg3 = ApplyConfig {
        config: &config3,
        state_dir: &state_dir,
        force: false,
        dry_run: false,
        machine_filter: None,
        resource_filter: None,
        tag_filter: None,
        group_filter: None,
        timeout_secs: None,
        force_unlock: false,
        progress: false,
        retry: 0,
        parallel: None,
        resource_timeout: None,
        rollback_on_failure: false,
        max_parallel: None,
        trace: false,
        run_id: None,
        refresh: false,
        force_tag: None,
    };
    let r3 = apply(&cfg3).unwrap();
    // config changed → converges. app unchanged but triggers: [config] → also converges
    assert_eq!(
        r3[0].resources_converged, 2,
        "config changed + app triggered"
    );
}

#[test]
fn test_fj224_trigger_no_fire_when_dep_unchanged() {
    let dir = tempfile::tempdir().unwrap();
    let state_dir = dir.path().join("state");
    std::fs::create_dir_all(&state_dir).unwrap();

    let yaml = r#"
version: "1.0"
name: test
machines:
  local:
    hostname: localhost
    addr: 127.0.0.1
resources:
  config:
    type: file
    machine: local
    path: /tmp/fj224b-config.txt
    content: "stable"
  app:
    type: file
    machine: local
    path: /tmp/fj224b-app.txt
    content: "app"
    depends_on: [config]
    triggers: [config]
"#;
    let config: ForjarConfig = serde_yaml_ng::from_str(yaml).unwrap();
    let cfg = ApplyConfig {
        config: &config,
        state_dir: &state_dir,
        force: false,
        dry_run: false,
        machine_filter: None,
        resource_filter: None,
        tag_filter: None,
        group_filter: None,
        timeout_secs: None,
        force_unlock: false,
        progress: false,
        retry: 0,
        parallel: None,
        resource_timeout: None,
        rollback_on_failure: false,
        max_parallel: None,
        trace: false,
        run_id: None,
        refresh: false,
        force_tag: None,
    };
    let r1 = apply(&cfg).unwrap();
    assert_eq!(r1[0].resources_converged, 2);

    // Second apply: nothing changed, trigger should NOT fire
    let r2 = apply(&cfg).unwrap();
    assert_eq!(r2[0].resources_converged, 0);
    assert_eq!(r2[0].resources_unchanged, 2);
}

#[test]
fn test_fj224_trigger_multiple_sources() {
    let dir = tempfile::tempdir().unwrap();
    let state_dir = dir.path().join("state");
    std::fs::create_dir_all(&state_dir).unwrap();

    let yaml1 = r#"
version: "1.0"
name: test
machines:
  local:
    hostname: localhost
    addr: 127.0.0.1
resources:
  db-config:
    type: file
    machine: local
    path: /tmp/fj224c-db.txt
    content: "db-v1"
  app-config:
    type: file
    machine: local
    path: /tmp/fj224c-app.txt
    content: "app-v1"
  service:
    type: file
    machine: local
    path: /tmp/fj224c-svc.txt
    content: "svc"
    depends_on: [db-config, app-config]
    triggers: [db-config, app-config]
"#;
    let config1: ForjarConfig = serde_yaml_ng::from_str(yaml1).unwrap();
    let cfg1 = ApplyConfig {
        config: &config1,
        state_dir: &state_dir,
        force: false,
        dry_run: false,
        machine_filter: None,
        resource_filter: None,
        tag_filter: None,
        group_filter: None,
        timeout_secs: None,
        force_unlock: false,
        progress: false,
        retry: 0,
        parallel: None,
        resource_timeout: None,
        rollback_on_failure: false,
        max_parallel: None,
        trace: false,
        run_id: None,
        refresh: false,
        force_tag: None,
    };
    let r1 = apply(&cfg1).unwrap();
    assert_eq!(r1[0].resources_converged, 3);

    // Change only db-config → service should be triggered
    let yaml2 = yaml1.replace("db-v1", "db-v2");
    let config2: ForjarConfig = serde_yaml_ng::from_str(&yaml2).unwrap();
    let cfg2 = ApplyConfig {
        config: &config2,
        state_dir: &state_dir,
        force: false,
        dry_run: false,
        machine_filter: None,
        resource_filter: None,
        tag_filter: None,
        group_filter: None,
        timeout_secs: None,
        force_unlock: false,
        progress: false,
        retry: 0,
        parallel: None,
        resource_timeout: None,
        rollback_on_failure: false,
        max_parallel: None,
        trace: false,
        run_id: None,
        refresh: false,
        force_tag: None,
    };
    let r2 = apply(&cfg2).unwrap();
    // db-config changed (converged), app-config unchanged, service triggered
    assert_eq!(
        r2[0].resources_converged, 2,
        "db-config + service triggered"
    );
}

#[test]
fn test_fj224_trigger_without_depends_on() {
    // Triggers can work independently of depends_on
    let dir = tempfile::tempdir().unwrap();
    let state_dir = dir.path().join("state");
    std::fs::create_dir_all(&state_dir).unwrap();

    let yaml = r#"
version: "1.0"
name: test
machines:
  local:
    hostname: localhost
    addr: 127.0.0.1
resources:
  config:
    type: file
    machine: local
    path: /tmp/fj224d-config.txt
    content: "v1"
  app:
    type: file
    machine: local
    path: /tmp/fj224d-app.txt
    content: "app"
    triggers: [config]
"#;
    let config: ForjarConfig = serde_yaml_ng::from_str(yaml).unwrap();
    let cfg = ApplyConfig {
        config: &config,
        state_dir: &state_dir,
        force: false,
        dry_run: false,
        machine_filter: None,
        resource_filter: None,
        tag_filter: None,
        group_filter: None,
        timeout_secs: None,
        force_unlock: false,
        progress: false,
        retry: 0,
        parallel: None,
        resource_timeout: None,
        rollback_on_failure: false,
        max_parallel: None,
        trace: false,
        run_id: None,
        refresh: false,
        force_tag: None,
    };
    let r1 = apply(&cfg).unwrap();
    assert_eq!(r1[0].resources_converged, 2);

    // Note: Without depends_on, execution order is alphabetical.
    // "app" sorts before "config", so trigger won't fire because
    // config hasn't converged yet when app is processed.
    // This is correct behavior — triggers require proper ordering
    // (either via depends_on or natural sort order).

    // With depends_on, changing config triggers app
    let yaml2 = r#"
version: "1.0"
name: test
machines:
  local:
    hostname: localhost
    addr: 127.0.0.1
resources:
  config:
    type: file
    machine: local
    path: /tmp/fj224d-config.txt
    content: "v2"
  app:
    type: file
    machine: local
    path: /tmp/fj224d-app.txt
    content: "app"
    depends_on: [config]
    triggers: [config]
"#;
    let config2: ForjarConfig = serde_yaml_ng::from_str(yaml2).unwrap();
    let cfg2 = ApplyConfig {
        config: &config2,
        state_dir: &state_dir,
        force: false,
        dry_run: false,
        machine_filter: None,
        resource_filter: None,
        tag_filter: None,
        group_filter: None,
        timeout_secs: None,
        force_unlock: false,
        progress: false,
        retry: 0,
        parallel: None,
        resource_timeout: None,
        rollback_on_failure: false,
        max_parallel: None,
        trace: false,
        run_id: None,
        refresh: false,
        force_tag: None,
    };
    let r2 = apply(&cfg2).unwrap();
    assert_eq!(
        r2[0].resources_converged, 2,
        "config changed + app triggered"
    );
}