test: fill gaps in types.rs, common.rs trigger functions, and add pipeline-trigger integration fixture (#21)

* Initial plan

* test: fill test gaps in types.rs, common.rs, and add pipeline-trigger-agent integration fixture

Co-authored-by: jamesadevine <4742697+jamesadevine@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: jamesadevine <4742697+jamesadevine@users.noreply.github.com>

Author: Copilot

src/compile/common.rs

@@ -656,4 +656,183 @@ mod tests {
         assert_eq!(sanitize_filename("agent@v1.0"), "agent-v1-0");
         assert_eq!(sanitize_filename("test_case"), "test-case");
     }
+
+    // ─── generate_pr_trigger ─────────────────────────────────────────────────
+
+    #[test]
+    fn test_generate_pr_trigger_no_triggers_no_schedule() {
+        let result = generate_pr_trigger(&None, false);
+        assert!(result.is_empty(), "Should be empty when no triggers configured");
+    }
+
+    #[test]
+    fn test_generate_pr_trigger_schedule_only() {
+        let result = generate_pr_trigger(&None, true);
+        assert!(result.contains("pr: none"));
+        assert!(result.contains("only run on schedule"));
+    }
+
+    #[test]
+    fn test_generate_pr_trigger_pipeline_only() {
+        let triggers = Some(crate::compile::types::TriggerConfig {
+            pipeline: Some(crate::compile::types::PipelineTrigger {
+                name: "Build".into(),
+                project: None,
+                branches: vec![],
+            }),
+        });
+        let result = generate_pr_trigger(&triggers, false);
+        assert!(result.contains("pr: none"));
+        assert!(result.contains("upstream pipeline"));
+    }
+
+    #[test]
+    fn test_generate_pr_trigger_both_pipeline_and_schedule() {
+        let triggers = Some(crate::compile::types::TriggerConfig {
+            pipeline: Some(crate::compile::types::PipelineTrigger {
+                name: "Build".into(),
+                project: None,
+                branches: vec![],
+            }),
+        });
+        let result = generate_pr_trigger(&triggers, true);
+        assert!(result.contains("pr: none"));
+        // Contains text indicating both reasons
+        assert!(result.contains("schedule") || result.contains("upstream pipeline"));
+    }
+
+    // ─── generate_ci_trigger ─────────────────────────────────────────────────
+
+    #[test]
+    fn test_generate_ci_trigger_no_triggers_no_schedule() {
+        let result = generate_ci_trigger(&None, false);
+        assert!(result.is_empty(), "Should be empty when no triggers configured");
+    }
+
+    #[test]
+    fn test_generate_ci_trigger_schedule_only() {
+        let result = generate_ci_trigger(&None, true);
+        assert_eq!(result, "trigger: none");
+    }
+
+    #[test]
+    fn test_generate_ci_trigger_pipeline_only() {
+        let triggers = Some(crate::compile::types::TriggerConfig {
+            pipeline: Some(crate::compile::types::PipelineTrigger {
+                name: "Build".into(),
+                project: None,
+                branches: vec![],
+            }),
+        });
+        let result = generate_ci_trigger(&triggers, false);
+        assert_eq!(result, "trigger: none");
+    }
+
+    #[test]
+    fn test_generate_ci_trigger_both_pipeline_and_schedule() {
+        let triggers = Some(crate::compile::types::TriggerConfig {
+            pipeline: Some(crate::compile::types::PipelineTrigger {
+                name: "Build".into(),
+                project: None,
+                branches: vec![],
+            }),
+        });
+        let result = generate_ci_trigger(&triggers, true);
+        assert_eq!(result, "trigger: none");
+    }
+
+    // ─── generate_pipeline_resources ─────────────────────────────────────────
+
+    #[test]
+    fn test_generate_pipeline_resources_no_triggers() {
+        let result = generate_pipeline_resources(&None).unwrap();
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_generate_pipeline_resources_empty_trigger_config() {
+        let triggers = Some(crate::compile::types::TriggerConfig { pipeline: None });
+        let result = generate_pipeline_resources(&triggers).unwrap();
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_generate_pipeline_resources_with_branches() {
+        let triggers = Some(crate::compile::types::TriggerConfig {
+            pipeline: Some(crate::compile::types::PipelineTrigger {
+                name: "Build Pipeline".into(),
+                project: Some("OtherProject".into()),
+                branches: vec!["main".into(), "release/*".into()],
+            }),
+        });
+        let result = generate_pipeline_resources(&triggers).unwrap();
+        assert!(result.contains("source: 'Build Pipeline'"));
+        assert!(result.contains("OtherProject"));
+        assert!(result.contains("main"));
+        assert!(result.contains("release/*"));
+        // Should use branch include list, not `trigger: true`
+        assert!(result.contains("branches:"));
+        assert!(!result.contains("trigger: true"));
+    }
+
+    #[test]
+    fn test_generate_pipeline_resources_without_branches_triggers_on_any() {
+        let triggers = Some(crate::compile::types::TriggerConfig {
+            pipeline: Some(crate::compile::types::PipelineTrigger {
+                name: "My Pipeline".into(),
+                project: None,
+                branches: vec![],
+            }),
+        });
+        let result = generate_pipeline_resources(&triggers).unwrap();
+        assert!(result.contains("source: 'My Pipeline'"));
+        assert!(result.contains("trigger: true"));
+        // No project when not specified
+        assert!(!result.contains("project:"));
+    }
+
+    #[test]
+    fn test_generate_pipeline_resources_resource_id_is_snake_case() {
+        let triggers = Some(crate::compile::types::TriggerConfig {
+            pipeline: Some(crate::compile::types::PipelineTrigger {
+                name: "My Build Pipeline".into(),
+                project: None,
+                branches: vec![],
+            }),
+        });
+        let result = generate_pipeline_resources(&triggers).unwrap();
+        // The pipeline resource ID should be snake_case derived from the name
+        assert!(result.contains("pipeline: my_build_pipeline"));
+    }
+
+    // ─── generate_cancel_previous_builds ─────────────────────────────────────
+
+    #[test]
+    fn test_generate_cancel_previous_builds_no_triggers() {
+        let result = generate_cancel_previous_builds(&None);
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_generate_cancel_previous_builds_no_pipeline_trigger() {
+        let triggers = Some(crate::compile::types::TriggerConfig { pipeline: None });
+        let result = generate_cancel_previous_builds(&triggers);
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn test_generate_cancel_previous_builds_with_pipeline_trigger() {
+        let triggers = Some(crate::compile::types::TriggerConfig {
+            pipeline: Some(crate::compile::types::PipelineTrigger {
+                name: "Build".into(),
+                project: None,
+                branches: vec![],
+            }),
+        });
+        let result = generate_cancel_previous_builds(&triggers);
+        assert!(!result.is_empty());
+        assert!(result.contains("Cancel previous queued builds"));
+        assert!(result.contains("SYSTEM_ACCESSTOKEN"));
+        assert!(result.contains("cancelling"));
+    }
 }

src/compile/types.rs

@@ -352,3 +352,149 @@ pub struct PipelineTrigger {
     #[serde(default)]
     pub branches: Vec<String>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // ─── PoolConfig deserialization ──────────────────────────────────────────
+
+    #[test]
+    fn test_pool_config_string_form() {
+        let yaml = "pool: MyPool";
+        let fm: serde_yaml::Value = serde_yaml::from_str(yaml).unwrap();
+        let pool: PoolConfig = serde_yaml::from_value(fm["pool"].clone()).unwrap();
+        assert_eq!(pool.name(), "MyPool");
+        assert_eq!(pool.os(), "linux"); // default
+    }
+
+    #[test]
+    fn test_pool_config_object_form_with_os() {
+        let yaml = "pool:\n  name: WinPool\n  os: windows";
+        let fm: serde_yaml::Value = serde_yaml::from_str(yaml).unwrap();
+        let pool: PoolConfig = serde_yaml::from_value(fm["pool"].clone()).unwrap();
+        assert_eq!(pool.name(), "WinPool");
+        assert_eq!(pool.os(), "windows");
+    }
+
+    #[test]
+    fn test_pool_config_object_form_default_os() {
+        let yaml = "pool:\n  name: LinuxPool";
+        let fm: serde_yaml::Value = serde_yaml::from_str(yaml).unwrap();
+        let pool: PoolConfig = serde_yaml::from_value(fm["pool"].clone()).unwrap();
+        assert_eq!(pool.name(), "LinuxPool");
+        assert_eq!(pool.os(), "linux");
+    }
+
+    #[test]
+    fn test_pool_config_default() {
+        let pool = PoolConfig::default();
+        assert_eq!(pool.name(), "AZS-1ES-L-MMS-ubuntu-22.04");
+        assert_eq!(pool.os(), "linux");
+    }
+
+    // ─── ScheduleConfig deserialization ─────────────────────────────────────
+
+    #[test]
+    fn test_schedule_config_simple_has_empty_branches() {
+        let sc = ScheduleConfig::Simple("daily around 14:00".to_string());
+        assert_eq!(sc.expression(), "daily around 14:00");
+        assert!(sc.branches().is_empty());
+    }
+
+    #[test]
+    fn test_schedule_config_with_options_returns_branches() {
+        let yaml = "run: weekly on monday\nbranches:\n  - main\n  - release/*";
+        let opts: ScheduleOptions = serde_yaml::from_str(yaml).unwrap();
+        let sc = ScheduleConfig::WithOptions(opts);
+        assert_eq!(sc.expression(), "weekly on monday");
+        assert_eq!(sc.branches(), &["main", "release/*"]);
+    }
+
+    #[test]
+    fn test_schedule_config_with_options_empty_branches() {
+        let yaml = "run: hourly";
+        let opts: ScheduleOptions = serde_yaml::from_str(yaml).unwrap();
+        let sc = ScheduleConfig::WithOptions(opts);
+        assert_eq!(sc.expression(), "hourly");
+        assert!(sc.branches().is_empty());
+    }
+
+    #[test]
+    fn test_schedule_config_deserialized_as_simple_string() {
+        let yaml = "schedule: daily around 14:00";
+        let fm: serde_yaml::Value = serde_yaml::from_str(yaml).unwrap();
+        let sc: ScheduleConfig = serde_yaml::from_value(fm["schedule"].clone()).unwrap();
+        assert_eq!(sc.expression(), "daily around 14:00");
+        assert!(sc.branches().is_empty());
+    }
+
+    #[test]
+    fn test_schedule_config_deserialized_as_object() {
+        let yaml = "schedule:\n  run: weekly on friday\n  branches:\n    - main\n    - develop";
+        let fm: serde_yaml::Value = serde_yaml::from_str(yaml).unwrap();
+        let sc: ScheduleConfig = serde_yaml::from_value(fm["schedule"].clone()).unwrap();
+        assert_eq!(sc.expression(), "weekly on friday");
+        assert_eq!(sc.branches(), &["main", "develop"]);
+    }
+
+    // ─── EngineConfig deserialization ────────────────────────────────────────
+
+    #[test]
+    fn test_engine_config_simple_string() {
+        let ec = EngineConfig::Simple("gpt-5.1".to_string());
+        assert_eq!(ec.model(), "gpt-5.1");
+        assert_eq!(ec.max_turns(), None);
+        assert_eq!(ec.timeout_minutes(), None);
+    }
+
+    #[test]
+    fn test_engine_config_full_object() {
+        let yaml = "model: claude-sonnet-4.5\nmax-turns: 50\ntimeout-minutes: 30";
+        let opts: EngineOptions = serde_yaml::from_str(yaml).unwrap();
+        let ec = EngineConfig::Full(opts);
+        assert_eq!(ec.model(), "claude-sonnet-4.5");
+        assert_eq!(ec.max_turns(), Some(50));
+        assert_eq!(ec.timeout_minutes(), Some(30));
+    }
+
+    #[test]
+    fn test_engine_config_full_object_partial_fields() {
+        let yaml = "max-turns: 10";
+        let opts: EngineOptions = serde_yaml::from_str(yaml).unwrap();
+        let ec = EngineConfig::Full(opts);
+        // model defaults to claude-opus-4.5 when not specified
+        assert_eq!(ec.model(), "claude-opus-4.5");
+        assert_eq!(ec.max_turns(), Some(10));
+        assert_eq!(ec.timeout_minutes(), None);
+    }
+
+    #[test]
+    fn test_engine_config_default() {
+        let ec = EngineConfig::default();
+        assert_eq!(ec.model(), "claude-opus-4.5");
+        assert_eq!(ec.max_turns(), None);
+        assert_eq!(ec.timeout_minutes(), None);
+    }
+
+    #[test]
+    fn test_engine_config_deserialized_as_string() {
+        let yaml = "engine: my-custom-model";
+        let fm: serde_yaml::Value = serde_yaml::from_str(yaml).unwrap();
+        let ec: EngineConfig = serde_yaml::from_value(fm["engine"].clone()).unwrap();
+        assert_eq!(ec.model(), "my-custom-model");
+        assert_eq!(ec.max_turns(), None);
+        assert_eq!(ec.timeout_minutes(), None);
+    }
+
+    #[test]
+    fn test_engine_config_deserialized_as_object() {
+        let yaml =
+            "engine:\n  model: claude-opus-4.5\n  max-turns: 50\n  timeout-minutes: 30";
+        let fm: serde_yaml::Value = serde_yaml::from_str(yaml).unwrap();
+        let ec: EngineConfig = serde_yaml::from_value(fm["engine"].clone()).unwrap();
+        assert_eq!(ec.model(), "claude-opus-4.5");
+        assert_eq!(ec.max_turns(), Some(50));
+        assert_eq!(ec.timeout_minutes(), Some(30));
+    }
+}