1  //! Integration tests for failure scenarios and error handling.
  2  //!
  3  //! Tests: network timeout, disk full, permission denied, corrupted binary, crash recovery
  4  
  5  mod common;
  6  
  7  use common::assertions::*;
  8  use common::fixtures::*;
  9  use common::mocks::*;
 10  use common::TestEnv;
 11  use std::io::Write;
 12  
 13  #[test]
 14  fn test_network_timeout_during_download() {
 15      // Setup
 16      let env = TestEnv::new().expect("Failed to create test environment");
 17      let release_server = MockReleaseServer::new("https://slow.ac-dc.network".to_string());
 18  
 19      // Simulate timeout by not adding file to server
 20      assert!(!release_server.file_exists("/releases/adnet-v1.0.0.tar.gz"));
 21  
 22      // Attempt to download (would timeout in real scenario)
 23      let result = release_server.get_file("/releases/adnet-v1.0.0.tar.gz");
 24      assert!(result.is_none(), "Expected download to fail");
 25  
 26      // Verify no partial files left behind
 27      let partial_file = env.base_path().join("adnet-v1.0.0.tar.gz.partial");
 28      assert!(!partial_file.exists(), "Partial file should be cleaned up");
 29  }
 30  
 31  #[test]
 32  fn test_disk_full_during_install() {
 33      // Setup
 34      let env = TestEnv::new().expect("Failed to create test environment");
 35  
 36      // Simulate disk full by trying to write huge file
 37      let huge_file = env.base_path().join("huge.bin");
 38      let result = std::fs::File::create(&huge_file);
 39  
 40      if let Ok(mut file) = result {
 41          // Try to write 10MB (would fail if disk full)
 42          let buffer = vec![0u8; 10 * 1024 * 1024];
 43          let write_result = file.write_all(&buffer);
 44  
 45          // In a real disk-full scenario, this would fail
 46          // For this test, we verify the error handling path exists
 47          if write_result.is_err() {
 48              // Cleanup should happen
 49              drop(file);
 50              std::fs::remove_file(&huge_file).ok();
 51              assert!(!huge_file.exists(), "Failed file should be cleaned up");
 52          }
 53      }
 54  
 55      // Verify installation directory is still intact
 56      assert!(env.install_dir.exists());
 57  }
 58  
 59  #[test]
 60  fn test_permission_denied_directories() {
 61      // Setup
 62      let env = TestEnv::new().expect("Failed to create test environment");
 63  
 64      // Create a directory with restricted permissions
 65      let restricted_dir = env.base_path().join("restricted");
 66      std::fs::create_dir(&restricted_dir).expect("Failed to create dir");
 67  
 68      #[cfg(unix)]
 69      {
 70          use std::os::unix::fs::PermissionsExt;
 71          let mut perms = std::fs::metadata(&restricted_dir).unwrap().permissions();
 72          perms.set_mode(0o000); // No permissions
 73          std::fs::set_permissions(&restricted_dir, perms).expect("Failed to set perms");
 74  
 75          // Attempt to create file in restricted directory
 76          let restricted_file = restricted_dir.join("test.bin");
 77          let result = std::fs::write(&restricted_file, b"test");
 78  
 79          // Should fail due to permissions
 80          assert!(result.is_err(), "Expected permission denied");
 81  
 82          // Restore permissions for cleanup
 83          let mut perms = std::fs::metadata(&restricted_dir).unwrap().permissions();
 84          perms.set_mode(0o755);
 85          std::fs::set_permissions(&restricted_dir, perms).ok();
 86      }
 87  
 88      #[cfg(not(unix))]
 89      {
 90          // Windows doesn't support Unix permissions
 91          // Just verify directory exists
 92          assert!(restricted_dir.exists());
 93      }
 94  }
 95  
 96  #[test]
 97  fn test_corrupted_binary_detection() {
 98      // Setup
 99      let env = TestEnv::new().expect("Failed to create test environment");
100      let release_server = MockReleaseServer::new("https://test.ac-dc.network".to_string());
101  
102      // Add corrupted binary (wrong checksum)
103      let corrupted_content = vec![0xFF; 1024]; // Garbage data
104      release_server.add_file("/releases/adnet-v1.0.0.tar.gz", corrupted_content.clone());
105  
106      // Add checksum for valid binary (will mismatch)
107      release_server.add_checksum("/releases/adnet-v1.0.0.tar.gz", "valid_checksum_abc123");
108  
109      // Simulate download and checksum verification
110      let downloaded = release_server
111          .get_file("/releases/adnet-v1.0.0.tar.gz")
112          .expect("Failed to get file");
113      let expected_checksum = release_server
114          .get_checksum("/releases/adnet-v1.0.0.tar.gz")
115          .expect("Failed to get checksum");
116  
117      // Calculate actual checksum
118      use sha2::{Digest, Sha256};
119      let mut hasher = Sha256::new();
120      hasher.update(&downloaded);
121      let actual_checksum = format!("{:x}", hasher.finalize());
122  
123      // Verify mismatch is detected
124      assert_ne!(
125          actual_checksum, expected_checksum,
126          "Checksums should not match for corrupted binary"
127      );
128  
129      // Corrupted binary should not be installed
130      let binary_path = env.install_dir.join("adnet");
131      assert!(
132          !binary_path.exists(),
133          "Corrupted binary should not be installed"
134      );
135  }
136  
137  #[test]
138  fn test_service_crash_recovery() {
139      // Setup
140      let env = TestEnv::new().expect("Failed to create test environment");
141      let systemd = MockSystemd::new();
142  
143      // Install and start service
144      let _binary = env
145          .create_binary("adnet", b"#!/bin/bash\necho running")
146          .expect("Failed to create binary");
147  
148      systemd.enable_service("adnet").expect("Failed to enable");
149      systemd.start_service("adnet").expect("Failed to start");
150  
151      assert_service_running(&systemd, "adnet");
152  
153      // Simulate crash (stop service unexpectedly)
154      systemd.stop_service("adnet").expect("Failed to stop");
155      assert_service_stopped(&systemd, "adnet");
156  
157      // Systemd should auto-restart (in real scenario with Restart=always)
158      // For mock, we manually restart to simulate
159      systemd.restart_service("adnet").expect("Failed to restart");
160  
161      // Verify service recovered
162      assert_service_running(&systemd, "adnet");
163  
164      // Check restart count increased
165      let services = systemd.services.lock().unwrap();
166      let state = services.get("adnet").expect("Service not found");
167      assert!(state.restarts > 0, "Restart count should be incremented");
168  }