Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

test(runtime): add cross-module integration tests (P1.2)

Jobdori69b9232acf5a
diff --git a/rust/crates/runtime/tests/integration_tests.rs b/rust/crates/runtime/tests/integration_tests.rs
new file mode 100644
index 00000000..030ff4c8
--- /dev/null
+++ b/rust/crates/runtime/tests/integration_tests.rs
@@ -0,0 +1,286 @@
+//! Integration tests for cross-module wiring.
+//!
+//! These tests verify that adjacent modules in the runtime crate actually
+//! connect correctly — catching wiring gaps that unit tests miss.
+
+use std::time::Duration;
+
+use runtime::{
+ apply_policy, BranchFreshness, DiffScope, LaneBlocker,
+ LaneContext, PolicyAction, PolicyCondition, PolicyEngine, PolicyRule,
+ ReconcileReason, ReviewStatus, StaleBranchAction, StaleBranchPolicy,
+};
+use runtime::green_contract::{GreenLevel, GreenContract, GreenContractOutcome};
+
+/// stale_branch + policy_engine integration:
+/// When a branch is detected stale, does it correctly flow through
+/// PolicyCondition::StaleBranch to generate the expected action?
+#[test]
+fn stale_branch_detection_flows_into_policy_engine() {
+ // given — a stale branch context (2 hours behind main, threshold is 1 hour)
+ let stale_context = LaneContext::new(
+ "stale-lane",
+ 0,
+ Duration::from_secs(2 * 60 * 60), // 2 hours stale
+ LaneBlocker::None,
+ ReviewStatus::Pending,
+ DiffScope::Full,
+ false,
+ );
+
+ let engine = PolicyEngine::new(vec![PolicyRule::new(
+ "stale-merge-forward",
+ PolicyCondition::StaleBranch,
+ PolicyAction::MergeForward,
+ 10,
+ )]);
+
+ // when
+ let actions = engine.evaluate(&stale_context);
+
+ // then
+ assert_eq!(actions, vec![PolicyAction::MergeForward]);
+}
+
+/// stale_branch + policy_engine: Fresh branch does NOT trigger stale rules
+#[test]
+fn fresh_branch_does_not_trigger_stale_policy() {
+ let fresh_context = LaneContext::new(
+ "fresh-lane",
+ 0,
+ Duration::from_secs(30 * 60), // 30 min stale — under 1 hour threshold
+ LaneBlocker::None,
+ ReviewStatus::Pending,
+ DiffScope::Full,
+ false,
+ );
+
+ let engine = PolicyEngine::new(vec![PolicyRule::new(
+ "stale-merge-forward",
+ PolicyCondition::StaleBranch,
+ PolicyAction::MergeForward,
+ 10,
+ )]);
+
+ let actions = engine.evaluate(&fresh_context);
+ assert!(actions.is_empty());
+}
+
+/// green_contract + policy_engine integration:
+/// A lane that meets its green contract should be mergeable
+#[test]
+fn green_contract_satisfied_allows_merge() {
+ let contract = GreenContract::new(GreenLevel::Workspace);
+ let satisfied = contract.is_satisfied_by(GreenLevel::Workspace);
+ assert!(satisfied);
+
+ let exceeded = contract.is_satisfied_by(GreenLevel::MergeReady);
+ assert!(exceeded);
+
+ let insufficient = contract.is_satisfied_by(GreenLevel::Package);
+ assert!(!insufficient);
+}
+
+/// green_contract + policy_engine:
+/// Lane with green level below contract requirement gets blocked
+#[test]
+fn green_contract_unsatisfied_blocks_merge() {
+ let context = LaneContext::new(
+ "partial-green-lane",
+ 1, // GreenLevel::Package as u8
+ Duration::from_secs(0),
+ LaneBlocker::None,
+ ReviewStatus::Pending,
+ DiffScope::Full,
+ false,
+ );
+
+ // This is a conceptual test — we need a way to express "requires workspace green"
+ // Currently LaneContext has raw green_level: u8, not a contract
+ // For now we just verify the policy condition works
+ let engine = PolicyEngine::new(vec![PolicyRule::new(
+ "workspace-green-required",
+ PolicyCondition::GreenAt { level: 3 }, // GreenLevel::Workspace
+ PolicyAction::MergeToDev,
+ 10,
+ )]);
+
+ let actions = engine.evaluate(&context);
+ assert!(actions.is_empty()); // level 1 < 3, so no merge
+}
+
+/// reconciliation + policy_engine integration:
+/// A reconciled lane should be handled by reconcile rules, not generic closeout
+#[test]
+fn reconciled_lane_matches_reconcile_condition() {
+ let context = LaneContext::reconciled("reconciled-lane");
+
+ let engine = PolicyEngine::new(vec![
+ PolicyRule::new(
+ "reconcile-first",
+ PolicyCondition::LaneReconciled,
+ PolicyAction::Reconcile {
+ reason: ReconcileReason::AlreadyMerged,
+ },
+ 5,
+ ),
+ PolicyRule::new(
+ "generic-closeout",
+ PolicyCondition::LaneCompleted,
+ PolicyAction::CloseoutLane,
+ 30,
+ ),
+ ]);
+
+ let actions = engine.evaluate(&context);
+
+ // Both rules fire — reconcile (priority 5) first, then closeout (priority 30)
+ assert_eq!(
+ actions,
+ vec![
+ PolicyAction::Reconcile {
+ reason: ReconcileReason::AlreadyMerged,
+ },
+ PolicyAction::CloseoutLane,
+ ]
+ );
+}
+
+/// stale_branch module: apply_policy generates correct actions
+#[test]
+fn stale_branch_apply_policy_produces_rebase_action() {
+ let stale = BranchFreshness::Stale {
+ commits_behind: 5,
+ missing_fixes: vec!["fix-123".to_string()],
+ };
+
+ let action = apply_policy(&stale, StaleBranchPolicy::AutoRebase);
+ assert_eq!(action, StaleBranchAction::Rebase);
+}
+
+#[test]
+fn stale_branch_apply_policy_produces_merge_forward_action() {
+ let stale = BranchFreshness::Stale {
+ commits_behind: 3,
+ missing_fixes: vec![],
+ };
+
+ let action = apply_policy(&stale, StaleBranchPolicy::AutoMergeForward);
+ assert_eq!(action, StaleBranchAction::MergeForward);
+}
+
+#[test]
+fn stale_branch_apply_policy_warn_only() {
+ let stale = BranchFreshness::Stale {
+ commits_behind: 2,
+ missing_fixes: vec!["fix-456".to_string()],
+ };
+
+ let action = apply_policy(&stale, StaleBranchPolicy::WarnOnly);
+ match action {
+ StaleBranchAction::Warn { message } => {
+ assert!(message.contains("2 commit(s) behind main"));
+ assert!(message.contains("fix-456"));
+ }
+ _ => panic!("expected Warn action, got {:?}", action),
+ }
+}
+
+#[test]
+fn stale_branch_fresh_produces_noop() {
+ let fresh = BranchFreshness::Fresh;
+ let action = apply_policy(&fresh, StaleBranchPolicy::AutoRebase);
+ assert_eq!(action, StaleBranchAction::Noop);
+}
+
+/// Combined flow: stale detection + policy + action
+#[test]
+fn end_to_end_stale_lane_gets_merge_forward_action() {
+ // Simulating what a harness would do:
+ // 1. Detect branch freshness
+ // 2. Build lane context from freshness + other signals
+ // 3. Run policy engine
+ // 4. Return actions
+
+ // given: detected stale state
+ let _freshness = BranchFreshness::Stale {
+ commits_behind: 5,
+ missing_fixes: vec!["fix-123".to_string()],
+ };
+
+ // when: build context and evaluate policy
+ let context = LaneContext::new(
+ "lane-9411",
+ 3, // Workspace green
+ Duration::from_secs(5 * 60 * 60), // 5 hours stale, definitely over threshold
+ LaneBlocker::None,
+ ReviewStatus::Approved,
+ DiffScope::Scoped,
+ false,
+ );
+
+ let engine = PolicyEngine::new(vec![
+ // Priority 5: Check if stale first
+ PolicyRule::new(
+ "auto-merge-forward-if-stale-and-approved",
+ PolicyCondition::And(vec![
+ PolicyCondition::StaleBranch,
+ PolicyCondition::ReviewPassed,
+ ]),
+ PolicyAction::MergeForward,
+ 5,
+ ),
+ // Priority 10: Normal stale handling
+ PolicyRule::new(
+ "stale-warning",
+ PolicyCondition::StaleBranch,
+ PolicyAction::Notify {
+ channel: "#build-status".to_string(),
+ },
+ 10,
+ ),
+ ]);
+
+ let actions = engine.evaluate(&context);
+
+ // then: both rules should fire (stale + approved matches both)
+ assert_eq!(
+ actions,
+ vec![
+ PolicyAction::MergeForward,
+ PolicyAction::Notify {
+ channel: "#build-status".to_string(),
+ },
+ ]
+ );
+}
+
+/// Fresh branch with approved review should merge (not stale-blocked)
+#[test]
+fn fresh_approved_lane_gets_merge_action() {
+ let context = LaneContext::new(
+ "fresh-approved-lane",
+ 3, // Workspace green
+ Duration::from_secs(30 * 60), // 30 min — under 1 hour threshold = fresh
+ LaneBlocker::None,
+ ReviewStatus::Approved,
+ DiffScope::Scoped,
+ false,
+ );
+
+ let engine = PolicyEngine::new(vec![
+ PolicyRule::new(
+ "merge-if-green-approved-not-stale",
+ PolicyCondition::And(vec![
+ PolicyCondition::GreenAt { level: 3 },
+ PolicyCondition::ReviewPassed,
+ // NOT PolicyCondition::StaleBranch — fresh lanes bypass this
+ ]),
+ PolicyAction::MergeToDev,
+ 5,
+ ),
+ ]);
+
+ let actions = engine.evaluate(&context);
+ assert_eq!(actions, vec![PolicyAction::MergeToDev]);
+}