1  //! Integration tests for multi-component scenarios.
  2  //!
  3  //! Tests: adnet + monitoring → start → metrics → stop
  4  
  5  mod common;
  6  
  7  use common::assertions::*;
  8  use common::fixtures::*;
  9  use common::mocks::*;
 10  use common::TestEnv;
 11  
 12  #[test]
 13  fn test_install_adnet_monitoring_together() {
 14      // Setup
 15      let env = TestEnv::new().expect("Failed to create test environment");
 16      let systemd = MockSystemd::new();
 17  
 18      // Install adnet
 19      let adnet_binary = env
 20          .create_binary("adnet", b"#!/bin/bash\necho 'adnet running'")
 21          .expect("Failed to create adnet binary");
 22  
 23      // Install monitoring component
 24      let monitor_binary = env
 25          .create_binary("adnet-monitor", b"#!/bin/bash\necho 'monitoring running'")
 26          .expect("Failed to create monitor binary");
 27  
 28      // Verify both binaries exist
 29      assert_binary_exists(&adnet_binary);
 30      assert_binary_exists(&monitor_binary);
 31  
 32      // Enable both services
 33      systemd.enable_service("adnet").expect("Failed to enable adnet");
 34      systemd
 35          .enable_service("adnet-monitor")
 36          .expect("Failed to enable monitor");
 37  
 38      assert_service_enabled(&systemd, "adnet");
 39      assert_service_enabled(&systemd, "adnet-monitor");
 40  }
 41  
 42  #[test]
 43  fn test_start_all_components_order() {
 44      // Setup
 45      let env = TestEnv::new().expect("Failed to create test environment");
 46      let systemd = MockSystemd::new();
 47  
 48      // Install components (order matters: adnet before monitoring)
 49      let _adnet = env
 50          .create_binary("adnet", b"#!/bin/bash\necho adnet")
 51          .expect("Failed to create adnet");
 52  
 53      let _monitor = env
 54          .create_binary("adnet-monitor", b"#!/bin/bash\necho monitor")
 55          .expect("Failed to create monitor");
 56  
 57      // Start in correct order
 58      systemd.enable_service("adnet").expect("Failed to enable adnet");
 59      systemd.start_service("adnet").expect("Failed to start adnet");
 60  
 61      // Verify adnet is running before starting monitor
 62      assert_service_running(&systemd, "adnet");
 63  
 64      // Now start monitor (depends on adnet)
 65      systemd
 66          .enable_service("adnet-monitor")
 67          .expect("Failed to enable monitor");
 68      systemd
 69          .start_service("adnet-monitor")
 70          .expect("Failed to start monitor");
 71  
 72      // Verify both running
 73      assert_service_running(&systemd, "adnet");
 74      assert_service_running(&systemd, "adnet-monitor");
 75  }
 76  
 77  #[test]
 78  fn test_metrics_collection_multi_node() {
 79      // Setup
 80      let env = TestEnv::new().expect("Failed to create test environment");
 81      let systemd = MockSystemd::new();
 82  
 83      // Install and start components
 84      let _adnet = env
 85          .create_binary("adnet", b"#!/bin/bash\necho running")
 86          .expect("Failed to create adnet");
 87  
 88      systemd.enable_service("adnet").expect("Failed to enable");
 89      systemd.start_service("adnet").expect("Failed to start");
 90  
 91      // Setup mock RPC client for metrics
 92      let rpc_client = MockRpcClient::new("http://localhost:3030".to_string());
 93  
 94      // Simulate metrics collection
 95      rpc_client.set_block_height(150);
 96      rpc_client.set_peer_count(8);
 97      rpc_client.set_syncing(false);
 98  
 99      // Verify metrics
100      assert_eq!(rpc_client.get_block_height(), 150);
101      assert_eq!(rpc_client.get_peer_count(), 8);
102      assert!(!rpc_client.is_syncing());
103  
104      // Create metrics file
105      let metrics_file = env.base_path().join("metrics.json");
106      let metrics = sample_node_metrics();
107      std::fs::write(&metrics_file, serde_json::to_string_pretty(&metrics).unwrap())
108          .expect("Failed to write metrics");
109  
110      // Verify metrics file
111      assert!(metrics_file.exists());
112      let loaded: serde_json::Value =
113          serde_json::from_str(&std::fs::read_to_string(&metrics_file).unwrap())
114              .expect("Invalid metrics");
115  
116      assert_eq!(loaded["block_height"], 100);
117      assert_eq!(loaded["peer_count"], 5);
118  }
119  
120  #[test]
121  fn test_stop_all_components_gracefully() {
122      // Setup
123      let env = TestEnv::new().expect("Failed to create test environment");
124      let systemd = MockSystemd::new();
125  
126      // Install and start all components
127      let _adnet = env
128          .create_binary("adnet", b"#!/bin/bash\necho adnet")
129          .expect("Failed to create adnet");
130  
131      let _monitor = env
132          .create_binary("adnet-monitor", b"#!/bin/bash\necho monitor")
133          .expect("Failed to create monitor");
134  
135      systemd.enable_service("adnet").expect("Failed to enable adnet");
136      systemd.start_service("adnet").expect("Failed to start adnet");
137  
138      systemd
139          .enable_service("adnet-monitor")
140          .expect("Failed to enable monitor");
141      systemd
142          .start_service("adnet-monitor")
143          .expect("Failed to start monitor");
144  
145      // Verify all running
146      assert_service_running(&systemd, "adnet");
147      assert_service_running(&systemd, "adnet-monitor");
148  
149      // Stop in reverse order (monitor before adnet)
150      systemd
151          .stop_service("adnet-monitor")
152          .expect("Failed to stop monitor");
153      assert_service_stopped(&systemd, "adnet-monitor");
154  
155      systemd.stop_service("adnet").expect("Failed to stop adnet");
156      assert_service_stopped(&systemd, "adnet");
157  
158      // Verify all stopped but still enabled
159      assert_service_enabled(&systemd, "adnet");
160      assert_service_enabled(&systemd, "adnet-monitor");
161  }