diff --git a/.gitignore b/.gitignore
index af49389..d6b3327 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 /.direnv
+/.nixos*
 /cli.html
 /deploy
 /flamegraph.svg
diff --git a/flake.nix b/flake.nix
index 54f04c2..1b36c59 100644
--- a/flake.nix
+++ b/flake.nix
@@ -203,13 +203,63 @@
             inherit src;
           };
 
-          sandhole-test = craneLib.cargoNextest (
-            commonArgs
-            // {
-              inherit cargoArtifacts;
-              cargoNextestExtraArgs = "-P nix";
-            }
-          );
+          sandhole-test =
+            let
+              sandhole-nextest-archive = craneLib.mkCargoDerivation (
+                commonArgs
+                // {
+                  inherit cargoArtifacts;
+                  pname = "sandhole-nextest-archive";
+                  doCheck = false;
+                  nativeBuildInputs = commonArgs.nativeBuildInputs ++ [ pkgs.cargo-nextest ];
+                  buildPhaseCargoCommand = ''
+                    cargo nextest archive --archive-format tar-zst --archive-file archive.tar.zst
+                  '';
+                  installPhaseCommand = ''
+                    mkdir -p $out
+                    cp archive.tar.zst $out
+                  '';
+                }
+              );
+            in
+            pkgs.testers.runNixOSTest {
+              name = "sandhole-nextest";
+              nodes = {
+                machine =
+                  { ... }:
+                  {
+                    virtualisation.diskSize = 4096;
+                    environment.defaultPackages = [
+                      pkgs.cargo
+                      pkgs.rustc
+                    ];
+                    systemd.services.sandhole-nextest = {
+                      description = "Sandhole tests";
+                      wantedBy = [ "multi-user.target" ];
+                      after = [ "network-online.target" ];
+                      wants = [ "network-online.target" ];
+                      script = ''
+                        cp -r ${src}/* .
+                        ${pkgs.cargo-nextest}/bin/cargo-nextest nextest run \
+                          --archive-file ${sandhole-nextest-archive}/archive.tar.zst \
+                          --workspace-remap .
+                      '';
+                      serviceConfig = {
+                        StateDirectory = "sandhole-nextest";
+                        StateDirectoryMode = "0750";
+                        WorkingDirectory = "/var/lib/sandhole-nextest";
+                        Type = "oneshot";
+                        RemainAfterExit = "yes";
+                        Restart = "no";
+                      };
+                    };
+                  };
+              };
+              testScript = ''
+                machine.start()
+                machine.wait_for_unit("sandhole-nextest.service")
+              '';
+            };
         };
 
         devShells.${system}.default = craneLib.devShell {
@@ -219,6 +269,7 @@
 
           packages = [
             pkgs.cargo-flamegraph
+            pkgs.cargo-nextest
             pkgs.just
             pkgs.mdbook
             pkgs.minica
diff --git a/src/acme.rs b/src/acme.rs
index 121946c..9d12678 100644
--- a/src/acme.rs
+++ b/src/acme.rs
@@ -246,7 +246,8 @@ o6ioYnJQHPsfaym/DY0seYghtg==
         mock.expect_state().never();
         let mut resolver = AcmeResolver::new(
             mock,
-            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache/").into(),
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/acme_cache/"),
             "foobar@sandhole.com.br".into(),
             true,
         );
@@ -308,7 +309,8 @@ o6ioYnJQHPsfaym/DY0seYghtg==
             .return_once(|_, _, _, _| mock_state);
         let mut resolver = AcmeResolver::new(
             mock,
-            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache/").into(),
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/acme_cache/"),
             "foobar@sandhole.com.br".into(),
             true,
         );
@@ -324,10 +326,10 @@ o6ioYnJQHPsfaym/DY0seYghtg==
         // Test SNI resolution for the valid domain
         let mut root_store = RootCertStore::empty();
         root_store.add_parsable_certificates(
-            CertificateDer::pem_file_iter(concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/tests/data/ca/rootCA.pem"
-            ))
+            CertificateDer::pem_file_iter(
+                std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/ca/rootCA.pem"),
+            )
             .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
             .expect("Failed to parse certificates"),
         );
diff --git a/src/certificates.rs b/src/certificates.rs
index 30eb5e1..5b98242 100644
--- a/src/certificates.rs
+++ b/src/certificates.rs
@@ -245,6 +245,7 @@ impl ResolvesServerCert for CertificateResolver {
 #[cfg_attr(coverage_nightly, coverage(off))]
 mod certificate_resolver_tests {
     use std::{
+        path::PathBuf,
         sync::{Arc, RwLock},
         time::Duration,
     };
@@ -255,8 +256,6 @@ mod certificate_resolver_tests {
 
     use super::{CertificateResolver, DummyAlpnChallengeResolver, MockAlpnChallengeResolver};
 
-    static CERTIFICATES_DIRECTORY: &str =
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates");
     // Certificate is valid for "foobar.tld" and "*.foobar.tld"
     static DOMAINS_FOOBAR: &[&str] = &["foobar.tld", "something.foobar.tld", "other.foobar.tld"];
     // Certificate is valid for "localhost"
@@ -280,7 +279,8 @@ mod certificate_resolver_tests {
     #[test_log::test(tokio::test)]
     async fn allows_valid_domains() {
         let resolver = CertificateResolver::watch(
-            CERTIFICATES_DIRECTORY.parse().unwrap(),
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/certificates"),
             RwLock::new(Box::new(DummyAlpnChallengeResolver)),
             Duration::from_secs(30),
         )
@@ -303,7 +303,8 @@ mod certificate_resolver_tests {
     #[test_log::test(tokio::test)]
     async fn forbids_invalid_domains() {
         let resolver = CertificateResolver::watch(
-            CERTIFICATES_DIRECTORY.parse().unwrap(),
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/certificates"),
             RwLock::new(Box::new(DummyAlpnChallengeResolver)),
             Duration::from_secs(30),
         )
@@ -335,12 +336,10 @@ mod certificate_resolver_tests {
         fs::create_dir_all(certs_dir.as_path())
             .await
             .expect("unable to create foobar.tld tempdir");
-        fs::write(
+        fs::copy(
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/certificates/foobar.tld/privkey.pem"),
             certs_dir.join("privkey.pem"),
-            include_bytes!(concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/tests/data/certificates/foobar.tld/privkey.pem"
-            )),
         )
         .await
         .expect("unable to copy privkey.pem to tempdir");
@@ -375,12 +374,10 @@ mod certificate_resolver_tests {
         fs::create_dir_all(certs_dir.as_path())
             .await
             .expect("unable to create foobar.tld tempdir");
-        fs::write(
+        fs::copy(
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/certificates/foobar.tld/fullchain.pem"),
             certs_dir.join("fullchain.pem"),
-            include_bytes!(concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/tests/data/certificates/foobar.tld/fullchain.pem"
-            )),
         )
         .await
         .expect("unable to copy fullchain.pem to tempdir");
@@ -418,12 +415,10 @@ mod certificate_resolver_tests {
         fs::write(certs_dir.join("fullchain.pem"), b"invalid certificate")
             .await
             .expect("unable to write fullchain.pem to tempdir");
-        fs::write(
+        fs::copy(
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/certificates/foobar.tld/privkey.pem"),
             certs_dir.join("privkey.pem"),
-            include_bytes!(concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/tests/data/certificates/foobar.tld/privkey.pem"
-            )),
         )
         .await
         .expect("unable to copy privkey.pem to tempdir");
@@ -458,12 +453,10 @@ mod certificate_resolver_tests {
         fs::create_dir_all(certs_dir.as_path())
             .await
             .expect("unable to create foobar.tld tempdir");
-        fs::write(
+        fs::copy(
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/certificates/foobar.tld/fullchain.pem"),
             certs_dir.join("fullchain.pem"),
-            include_bytes!(concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/tests/data/certificates/foobar.tld/fullchain.pem"
-            )),
         )
         .await
         .expect("unable to copy fullchain.pem to tempdir");
@@ -493,7 +486,8 @@ mod certificate_resolver_tests {
 
         let resolver = Arc::new(
             CertificateResolver::watch(
-                CERTIFICATES_DIRECTORY.parse().unwrap(),
+                PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/certificates"),
                 RwLock::new(Box::new(mock)),
                 Duration::from_secs(30),
             )
diff --git a/src/fingerprints.rs b/src/fingerprints.rs
index 086d63a..e906ffc 100644
--- a/src/fingerprints.rs
+++ b/src/fingerprints.rs
@@ -256,21 +256,19 @@ impl FingerprintsValidator {
 #[cfg(test)]
 #[cfg_attr(coverage_nightly, coverage(off))]
 mod fingerprints_validator_tests {
-    use std::{path::PathBuf, str::FromStr, time::Duration};
+    use std::{path::PathBuf, time::Duration};
 
     use russh::keys::{HashAlg, parse_public_key_base64};
 
     use super::{AuthenticationType, FingerprintsValidator};
 
-    static USER_KEYS_DIRECTORY: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys");
-    static ADMIN_KEYS_DIRECTORY: &str =
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys");
-
     #[test_log::test(tokio::test)]
     async fn authenticates_user_keys() {
         let validator = FingerprintsValidator::watch(
-            USER_KEYS_DIRECTORY.parse().unwrap(),
-            ADMIN_KEYS_DIRECTORY.parse().unwrap(),
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/user_keys"),
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/admin_keys"),
             Duration::from_secs(30),
         )
         .await
@@ -314,8 +312,10 @@ mod fingerprints_validator_tests {
     #[test_log::test(tokio::test)]
     async fn gets_data_for_fingerprints() {
         let validator = FingerprintsValidator::watch(
-            USER_KEYS_DIRECTORY.parse().unwrap(),
-            ADMIN_KEYS_DIRECTORY.parse().unwrap(),
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/user_keys"),
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/admin_keys"),
             Duration::from_secs(30),
         )
         .await
@@ -346,9 +346,8 @@ mod fingerprints_validator_tests {
         assert_eq!(admin_key_data.algorithm.as_str(), "ssh-ed25519");
         assert_eq!(
             admin_key_data.file,
-            PathBuf::from_str(env!("CARGO_MANIFEST_DIR"))
-                .unwrap()
-                .join("tests/data/admin_keys/admin.pub")
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/admin_keys/admin.pub"),
         );
 
         let user_one_key_data = validator
@@ -359,9 +358,8 @@ mod fingerprints_validator_tests {
         assert_eq!(user_one_key_data.algorithm.as_str(), "ssh-ed25519");
         assert_eq!(
             user_one_key_data.file,
-            PathBuf::from_str(env!("CARGO_MANIFEST_DIR"))
-                .unwrap()
-                .join("tests/data/user_keys/keys_1_2.pub")
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/user_keys/keys_1_2.pub"),
         );
 
         let user_two_key_data = validator
@@ -372,9 +370,8 @@ mod fingerprints_validator_tests {
         assert_eq!(user_two_key_data.algorithm.as_str(), "ssh-rsa");
         assert_eq!(
             user_two_key_data.file,
-            PathBuf::from_str(env!("CARGO_MANIFEST_DIR"))
-                .unwrap()
-                .join("tests/data/user_keys/keys_1_2.pub")
+            PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/user_keys/keys_1_2.pub"),
         );
 
         assert!(
diff --git a/src/login.rs b/src/login.rs
index e48aa83..2cf6501 100644
--- a/src/login.rs
+++ b/src/login.rs
@@ -112,7 +112,6 @@ mod api_login_tests {
     use std::{
         net::{IpAddr, Ipv4Addr, SocketAddr},
         path::PathBuf,
-        str::FromStr,
         sync::Arc,
     };
 
@@ -216,10 +215,10 @@ mod api_login_tests {
         let mut mock = MockConfigurer::new();
         let mut root_store = RootCertStore::empty();
         root_store.add_parsable_certificates(
-            CertificateDer::pem_file_iter(concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/tests/data/ca/rootCA.pem"
-            ))
+            CertificateDer::pem_file_iter(
+                PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/ca/rootCA.pem"),
+            )
             .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
             .expect("Failed to parse client certificates"),
         );
@@ -253,16 +252,16 @@ mod api_login_tests {
             .unwrap()
             .with_no_client_auth()
             .with_single_cert(
-                CertificateDer::pem_file_iter(concat!(
-                    env!("CARGO_MANIFEST_DIR"),
-                    "/tests/data/certificates/localhost/fullchain.pem"
-                ))
+                CertificateDer::pem_file_iter(
+                    PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                        .join("tests/data/certificates/localhost/fullchain.pem"),
+                )
                 .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
                 .expect("Failed to parse server certificates"),
-                PrivateKeyDer::from_pem_file(concat!(
-                    env!("CARGO_MANIFEST_DIR"),
-                    "/tests/data/certificates/localhost/privkey.pem"
-                ))
+                PrivateKeyDer::from_pem_file(
+                    PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                        .join("tests/data/certificates/localhost/privkey.pem"),
+                )
                 .expect("Failed to parse server key"),
             )
             .expect("Failed to build server config"),
@@ -499,8 +498,7 @@ mod api_login_tests {
         let mut root_store = RootCertStore::empty();
         root_store.add_parsable_certificates(
             CertificateDer::pem_file_iter(
-                PathBuf::from_str(env!("CARGO_MANIFEST_DIR"))
-                    .unwrap()
+                PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
                     .join("tests/data/ca/rootCA.pem"),
             )
             .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
@@ -548,8 +546,7 @@ mod api_login_tests {
         let mut root_store = RootCertStore::empty();
         root_store.add_parsable_certificates(
             CertificateDer::pem_file_iter(
-                PathBuf::from_str(env!("CARGO_MANIFEST_DIR"))
-                    .unwrap()
+                PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
                     .join("tests/data/ca/rootCA.pem"),
             )
             .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
@@ -575,15 +572,13 @@ mod api_login_tests {
             .with_no_client_auth()
             .with_single_cert(
                 CertificateDer::pem_file_iter(
-                    PathBuf::from_str(env!("CARGO_MANIFEST_DIR"))
-                        .unwrap()
+                    PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
                         .join("tests/data/certificates/localhost/fullchain.pem"),
                 )
                 .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
                 .expect("Failed to parse server certificates"),
                 PrivateKeyDer::from_pem_file(
-                    PathBuf::from_str(env!("CARGO_MANIFEST_DIR"))
-                        .unwrap()
+                    PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
                         .join("tests/data/certificates/localhost/privkey.pem"),
                 )
                 .expect("Failed to parse server key"),
diff --git a/src/tls.rs b/src/tls.rs
index 79726d8..b3804e9 100644
--- a/src/tls.rs
+++ b/src/tls.rs
@@ -24,7 +24,7 @@ pub(crate) async fn peek_sni_and_alpn(buf: &[u8]) -> Option<TlsPeekData> {
 #[cfg(test)]
 #[cfg_attr(coverage_nightly, coverage(off))]
 mod peek_sni_and_alpn_tests {
-    use std::sync::Arc;
+    use std::{path::PathBuf, sync::Arc};
 
     use rustls_pki_types::pem::PemObject;
     use tokio::io::{AsyncReadExt, duplex};
@@ -41,10 +41,10 @@ mod peek_sni_and_alpn_tests {
     async fn fails_on_plain_message() {
         let mut root_store = rustls::RootCertStore::empty();
         root_store.add_parsable_certificates(
-            rustls_pki_types::CertificateDer::pem_file_iter(concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/tests/data/ca/rootCA.pem"
-            ))
+            rustls_pki_types::CertificateDer::pem_file_iter(
+                PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/ca/rootCA.pem"),
+            )
             .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
             .expect("Failed to parse client certificates"),
         );
@@ -77,10 +77,10 @@ mod peek_sni_and_alpn_tests {
     async fn fails_on_missing_sni() {
         let mut root_store = rustls::RootCertStore::empty();
         root_store.add_parsable_certificates(
-            rustls_pki_types::CertificateDer::pem_file_iter(concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/tests/data/ca/rootCA.pem"
-            ))
+            rustls_pki_types::CertificateDer::pem_file_iter(
+                PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/ca/rootCA.pem"),
+            )
             .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
             .expect("Failed to parse client certificates"),
         );
@@ -114,10 +114,10 @@ mod peek_sni_and_alpn_tests {
     async fn returns_sni_data() {
         let mut root_store = rustls::RootCertStore::empty();
         root_store.add_parsable_certificates(
-            rustls_pki_types::CertificateDer::pem_file_iter(concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/tests/data/ca/rootCA.pem"
-            ))
+            rustls_pki_types::CertificateDer::pem_file_iter(
+                PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/ca/rootCA.pem"),
+            )
             .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
             .expect("Failed to parse client certificates"),
         );
@@ -152,10 +152,10 @@ mod peek_sni_and_alpn_tests {
     async fn returns_sni_and_alpn_data() {
         let mut root_store = rustls::RootCertStore::empty();
         root_store.add_parsable_certificates(
-            rustls_pki_types::CertificateDer::pem_file_iter(concat!(
-                env!("CARGO_MANIFEST_DIR"),
-                "/tests/data/ca/rootCA.pem"
-            ))
+            rustls_pki_types::CertificateDer::pem_file_iter(
+                PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/ca/rootCA.pem"),
+            )
             .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
             .expect("Failed to parse client certificates"),
         );
diff --git a/tests/integration/admin_interface.rs b/tests/integration/admin_interface.rs
index edf195e..d51bd49 100644
--- a/tests/integration/admin_interface.rs
+++ b/tests/integration/admin_interface.rs
@@ -27,15 +27,30 @@ async fn admin_interface() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -63,7 +78,8 @@ async fn admin_interface() {
     // 2. Start SSH clients that will be proxied
     let key = Arc::new(
         load_secret_key(
-            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/private_keys/key1"),
             None,
         )
         .expect("Missing file key1"),
@@ -143,7 +159,8 @@ async fn admin_interface() {
 
     // 3. Request admin pty
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/admin"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/admin"),
         None,
     )
     .expect("Missing file admin");
diff --git a/tests/integration/admin_missing_pty.rs b/tests/integration/admin_missing_pty.rs
index 3f17f4f..6cd21e1 100644
--- a/tests/integration/admin_missing_pty.rs
+++ b/tests/integration/admin_missing_pty.rs
@@ -27,15 +27,30 @@ async fn admin_missing_pty() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -62,7 +77,8 @@ async fn admin_missing_pty() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -105,7 +121,8 @@ async fn admin_missing_pty() {
 
     // 3. Request admin pty
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/admin"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/admin"),
         None,
     )
     .expect("Missing file admin");
diff --git a/tests/integration/admin_no_interface_if_forwarding.rs b/tests/integration/admin_no_interface_if_forwarding.rs
index 98ec31f..772ec0b 100644
--- a/tests/integration/admin_no_interface_if_forwarding.rs
+++ b/tests/integration/admin_no_interface_if_forwarding.rs
@@ -25,15 +25,30 @@ async fn admin_no_interface_if_forwarding() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -60,7 +75,8 @@ async fn admin_no_interface_if_forwarding() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key2"),
         None,
     )
     .expect("Missing file key1");
@@ -103,7 +119,8 @@ async fn admin_no_interface_if_forwarding() {
 
     // 3. Request admin pty
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/admin"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/admin"),
         None,
     )
     .expect("Missing file admin");
diff --git a/tests/integration/admin_no_interface_if_proxying.rs b/tests/integration/admin_no_interface_if_proxying.rs
index d062e14..2d0df4e 100644
--- a/tests/integration/admin_no_interface_if_proxying.rs
+++ b/tests/integration/admin_no_interface_if_proxying.rs
@@ -25,15 +25,30 @@ async fn admin_no_interface_if_proxying() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -60,7 +75,8 @@ async fn admin_no_interface_if_proxying() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -89,7 +105,8 @@ async fn admin_no_interface_if_proxying() {
 
     // 3. Create forwarding and fail to open admin interface
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/admin"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/admin"),
         None,
     )
     .expect("Missing file admin");
@@ -135,7 +152,8 @@ async fn admin_no_interface_if_proxying() {
 
     // 3. Open admin interface and fail to create forwarding
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/admin"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/admin"),
         None,
     )
     .expect("Missing file admin");
diff --git a/tests/integration/admin_prometheus.rs b/tests/integration/admin_prometheus.rs
index 3a76046..bfc4044 100644
--- a/tests/integration/admin_prometheus.rs
+++ b/tests/integration/admin_prometheus.rs
@@ -25,15 +25,30 @@ async fn admin_prometheus() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -59,7 +74,8 @@ async fn admin_prometheus() {
 
     // 2. Start SSH admin client that will local forward the Prometheus service
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/admin"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/admin"),
         None,
     )
     .expect("Missing file admin");
diff --git a/tests/integration/admin_remove_user.rs b/tests/integration/admin_remove_user.rs
index 196abc0..806b735 100644
--- a/tests/integration/admin_remove_user.rs
+++ b/tests/integration/admin_remove_user.rs
@@ -35,15 +35,30 @@ async fn admin_remove_user() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -72,7 +87,8 @@ async fn admin_remove_user() {
 
     // 2. Start SSH client that will host the login API and not be removed
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -129,7 +145,8 @@ async fn admin_remove_user() {
 
     // 4. Request admin pty
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/admin"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/admin"),
         None,
     )
     .expect("Missing file admin");
diff --git a/tests/integration/admin_restricted_aliases.rs b/tests/integration/admin_restricted_aliases.rs
index 9ffcf50..fae98bb 100644
--- a/tests/integration/admin_restricted_aliases.rs
+++ b/tests/integration/admin_restricted_aliases.rs
@@ -19,15 +19,30 @@ async fn admin_restricted_aliases() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -53,7 +68,8 @@ async fn admin_restricted_aliases() {
 
     // 2. Start SSH admin client that will local forward the Prometheus service
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/admin"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/admin"),
         None,
     )
     .expect("Missing file admin");
@@ -82,7 +98,8 @@ async fn admin_restricted_aliases() {
 
     // 3. Start SSH user client that will fail to local forward the Prometheus service
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/admin_window_change.rs b/tests/integration/admin_window_change.rs
index ce58ffc..655cb6b 100644
--- a/tests/integration/admin_window_change.rs
+++ b/tests/integration/admin_window_change.rs
@@ -26,15 +26,30 @@ async fn admin_window_change() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -61,7 +76,8 @@ async fn admin_window_change() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key2"),
         None,
     )
     .expect("Missing file key1");
@@ -104,7 +120,8 @@ async fn admin_window_change() {
 
     // 3. Request admin pty
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/admin"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/admin"),
         None,
     )
     .expect("Missing file admin");
diff --git a/tests/integration/alias_aliasing_tunnel.rs b/tests/integration/alias_aliasing_tunnel.rs
index d53d3f8..1619e63 100644
--- a/tests/integration/alias_aliasing_tunnel.rs
+++ b/tests/integration/alias_aliasing_tunnel.rs
@@ -26,15 +26,30 @@ async fn alias_aliasing_tunnel() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -60,7 +75,8 @@ async fn alias_aliasing_tunnel() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/alias_cannot_be_localhost.rs b/tests/integration/alias_cannot_be_localhost.rs
index 7a8d71a..bf78933 100644
--- a/tests/integration/alias_cannot_be_localhost.rs
+++ b/tests/integration/alias_cannot_be_localhost.rs
@@ -23,15 +23,30 @@ async fn alias_cannot_be_localhost() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -57,7 +72,8 @@ async fn alias_cannot_be_localhost() {
 
     // 2a. Start SSH client that will fail to convert HTTP into alias via `tcp-alias`
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -102,7 +118,8 @@ async fn alias_cannot_be_localhost() {
     assert!(session.is_closed(), "session should've been closed");
     // 2b. Start SSH client that will fail to convert HTTP into alias via `allowed-fingerprints`
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -150,7 +167,8 @@ async fn alias_cannot_be_localhost() {
     assert!(session.is_closed(), "session should've been closed");
     // 2c. Start SSH client that will fail to create localhost HTTP after invoking `tcp-alias`
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -194,7 +212,8 @@ async fn alias_cannot_be_localhost() {
     assert!(!session.is_closed(), "session shouldn't have been closed");
     // 2d. Start SSH client that will fail to create localhost HTTP after invoking `allowed-fingerprints`
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -242,7 +261,8 @@ async fn alias_cannot_be_localhost() {
 
     // 3a. Start SSH client that will fail to convert TCP port into alias via `tcp-alias`
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -287,7 +307,8 @@ async fn alias_cannot_be_localhost() {
     assert!(session.is_closed(), "session should've been closed");
     // 3b. Start SSH client that will fail to convert TCP port into alias via `allowed-fingerprints`
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -335,7 +356,8 @@ async fn alias_cannot_be_localhost() {
     assert!(session.is_closed(), "session should've been closed");
     // 3c. Start SSH client that will fail to create localhost TCP port after invoking `tcp-alias`
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -379,7 +401,8 @@ async fn alias_cannot_be_localhost() {
     assert!(!session.is_closed(), "session shouldn't have been closed");
     // 3d. Start SSH client that will fail to create localhost TCP port after invoking `allowed-fingerprints`
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/alias_http_aliases.rs b/tests/integration/alias_http_aliases.rs
index e8bd546..06b1333 100644
--- a/tests/integration/alias_http_aliases.rs
+++ b/tests/integration/alias_http_aliases.rs
@@ -31,15 +31,30 @@ async fn alias_http_aliases() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -66,7 +81,8 @@ async fn alias_http_aliases() {
     // 2. Start SSH clients that will be proxied via alias for specific fingerprints
     // 2a. Tunnel first, then exec allowed-fingerprints
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -114,7 +130,8 @@ async fn alias_http_aliases() {
     assert_eq!(channel_id, channel.id());
     // 2b. exec allowed-fingerprints first, then alias
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -164,7 +181,8 @@ async fn alias_http_aliases() {
     // 3. Start SSH client that will be proxied via alias for all fingerprints
     // 3a. Tunnel first, then exec tcp-alias
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key2"),
         None,
     )
     .expect("Missing file key2");
@@ -203,7 +221,8 @@ async fn alias_http_aliases() {
     assert_eq!(channel_id, channel.id());
     // 3b. exec tcp-alias first, then alias
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key2"),
         None,
     )
     .expect("Missing file key2");
@@ -243,7 +262,8 @@ async fn alias_http_aliases() {
 
     // 4. Local-forward with valid key
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/alias_local_forward_existing_http.rs b/tests/integration/alias_local_forward_existing_http.rs
index eabc471..0102888 100644
--- a/tests/integration/alias_local_forward_existing_http.rs
+++ b/tests/integration/alias_local_forward_existing_http.rs
@@ -34,15 +34,30 @@ async fn alias_local_forward_existing_http() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -68,7 +83,8 @@ async fn alias_local_forward_existing_http() {
 
     // 2. Start SSH client that will be proxied via alias for specific fingerprints
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/alias_pool_limit.rs b/tests/integration/alias_pool_limit.rs
index 922536d..5a1b844 100644
--- a/tests/integration/alias_pool_limit.rs
+++ b/tests/integration/alias_pool_limit.rs
@@ -30,15 +30,30 @@ async fn alias_pool_limit() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -65,7 +80,8 @@ async fn alias_pool_limit() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/alias_pool_timeout.rs b/tests/integration/alias_pool_timeout.rs
index 1aeb159..255653e 100644
--- a/tests/integration/alias_pool_timeout.rs
+++ b/tests/integration/alias_pool_timeout.rs
@@ -33,15 +33,30 @@ async fn alias_pool_timeout() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -69,7 +84,8 @@ async fn alias_pool_timeout() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/alias_rate_limit_download.rs b/tests/integration/alias_rate_limit_download.rs
index 13ae7ae..a5dc97d 100644
--- a/tests/integration/alias_rate_limit_download.rs
+++ b/tests/integration/alias_rate_limit_download.rs
@@ -28,15 +28,30 @@ async fn alias_rate_limit_download() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -64,7 +79,8 @@ async fn alias_rate_limit_download() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/alias_rate_limit_upload.rs b/tests/integration/alias_rate_limit_upload.rs
index c4fce25..41d7238 100644
--- a/tests/integration/alias_rate_limit_upload.rs
+++ b/tests/integration/alias_rate_limit_upload.rs
@@ -27,15 +27,30 @@ async fn alias_rate_limit_upload() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -63,7 +78,8 @@ async fn alias_rate_limit_upload() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/alias_reject_special_ports.rs b/tests/integration/alias_reject_special_ports.rs
index 09ccca8..4355ce1 100644
--- a/tests/integration/alias_reject_special_ports.rs
+++ b/tests/integration/alias_reject_special_ports.rs
@@ -19,15 +19,30 @@ async fn alias_reject_special_ports() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -54,7 +69,8 @@ async fn alias_reject_special_ports() {
     for port in [0, 10] {
         // 2. Start SSH client that will fail to proxy on the port
         let key = load_secret_key(
-            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/private_keys/key1"),
             None,
         )
         .expect("Missing file key1");
diff --git a/tests/integration/alias_require_allowed_fingerprints.rs b/tests/integration/alias_require_allowed_fingerprints.rs
index 4e789ea..ffbe511 100644
--- a/tests/integration/alias_require_allowed_fingerprints.rs
+++ b/tests/integration/alias_require_allowed_fingerprints.rs
@@ -26,15 +26,30 @@ async fn alias_require_allowed_fingerprints() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -61,7 +76,8 @@ async fn alias_require_allowed_fingerprints() {
 
     // 2. Start SSH client that will be proxied via alias for specific fingerprints
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -104,7 +120,8 @@ async fn alias_require_allowed_fingerprints() {
 
     // 3a. Local-forward with valid key
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/alias_timeout.rs b/tests/integration/alias_timeout.rs
index 60f0ddd..013f232 100644
--- a/tests/integration/alias_timeout.rs
+++ b/tests/integration/alias_timeout.rs
@@ -25,15 +25,30 @@ async fn alias_timeout() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -60,7 +75,8 @@ async fn alias_timeout() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -171,7 +187,8 @@ async fn alias_timeout() {
 
     // 3. Start authenticated SSH client that will forward the proxies via aliasing
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key2"),
         None,
     )
     .expect("Missing file key2");
diff --git a/tests/integration/auth_ignore_user_actions.rs b/tests/integration/auth_ignore_user_actions.rs
index bea7b02..67af372 100644
--- a/tests/integration/auth_ignore_user_actions.rs
+++ b/tests/integration/auth_ignore_user_actions.rs
@@ -18,15 +18,30 @@ async fn auth_ignore_user_actions() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -54,7 +69,8 @@ async fn auth_ignore_user_actions() {
 
     // 2. Start SSH client that will be proxied via alias
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/auth_prevent_unauthorized_actions.rs b/tests/integration/auth_prevent_unauthorized_actions.rs
index 93edb4f..ade9d06 100644
--- a/tests/integration/auth_prevent_unauthorized_actions.rs
+++ b/tests/integration/auth_prevent_unauthorized_actions.rs
@@ -29,15 +29,30 @@ async fn auth_prevent_unauthorized_actions() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -65,7 +80,8 @@ async fn auth_prevent_unauthorized_actions() {
 
     // 2. Start SSH client that will be proxied via alias
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/auth_self_hosted_login_api.rs b/tests/integration/auth_self_hosted_login_api.rs
index 9ce44ff..afd0521 100644
--- a/tests/integration/auth_self_hosted_login_api.rs
+++ b/tests/integration/auth_self_hosted_login_api.rs
@@ -34,15 +34,30 @@ async fn auth_self_hosted_login_api() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -70,7 +85,8 @@ async fn auth_self_hosted_login_api() {
 
     // 2. Start SSH client that will start the login API
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/config_disable_aliasing.rs b/tests/integration/config_disable_aliasing.rs
index e508508..f113613 100644
--- a/tests/integration/config_disable_aliasing.rs
+++ b/tests/integration/config_disable_aliasing.rs
@@ -34,15 +34,30 @@ async fn config_disable_aliasing() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -69,7 +84,8 @@ async fn config_disable_aliasing() {
 
     // 2. Start SSH client that will fail to alias
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -124,7 +140,8 @@ async fn config_disable_aliasing() {
         "Didn't remove connection after runnning invalid tcp-alias command"
     );
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -175,7 +192,8 @@ async fn config_disable_aliasing() {
         "Didn't remove connection after runnning invalid tcp-alias command"
     );
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -216,7 +234,8 @@ async fn config_disable_aliasing() {
 
     // 3. Start SSH proxy that will fail to local forward
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/config_disable_http.rs b/tests/integration/config_disable_http.rs
index 06436be..78fbad3 100644
--- a/tests/integration/config_disable_http.rs
+++ b/tests/integration/config_disable_http.rs
@@ -31,15 +31,30 @@ async fn config_disable_http() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -74,7 +89,8 @@ async fn config_disable_http() {
 
     // 2. Start SSH client that will fail to bind HTTP
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -139,7 +155,8 @@ async fn config_disable_http() {
 
     // 3. Start SSH client that manages to bind TCP
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/config_disable_https.rs b/tests/integration/config_disable_https.rs
index 9bd1fae..8984e9b 100644
--- a/tests/integration/config_disable_https.rs
+++ b/tests/integration/config_disable_https.rs
@@ -18,15 +18,30 @@ async fn config_disable_https() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
diff --git a/tests/integration/config_disable_prometheus.rs b/tests/integration/config_disable_prometheus.rs
index 37cd610..751a52a 100644
--- a/tests/integration/config_disable_prometheus.rs
+++ b/tests/integration/config_disable_prometheus.rs
@@ -19,15 +19,30 @@ async fn config_disable_prometheus() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -54,7 +69,8 @@ async fn config_disable_prometheus() {
 
     // 2. Start SSH admin client that will fail to local forward the Prometheus service
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/admin"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/admin"),
         None,
     )
     .expect("Missing file admin");
diff --git a/tests/integration/config_disable_tcp.rs b/tests/integration/config_disable_tcp.rs
index 802175a..ca52e6b 100644
--- a/tests/integration/config_disable_tcp.rs
+++ b/tests/integration/config_disable_tcp.rs
@@ -31,15 +31,30 @@ async fn config_disable_tcp() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -66,7 +81,8 @@ async fn config_disable_tcp() {
 
     // 2. Start SSH client that will fail to bind TCP
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/config_invalid_options.rs b/tests/integration/config_invalid_options.rs
index 79d296a..f5e64a3 100644
--- a/tests/integration/config_invalid_options.rs
+++ b/tests/integration/config_invalid_options.rs
@@ -21,15 +21,30 @@ async fn config_invalid_options() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
         "--disable-http",
@@ -51,15 +66,30 @@ async fn config_invalid_options() {
         "sandhole",
         "--no-domain",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
         "--http-port=18080",
@@ -80,15 +110,30 @@ async fn config_invalid_options() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
         "--http-port=18080",
diff --git a/tests/integration/config_invalid_secret_key_contents.rs b/tests/integration/config_invalid_secret_key_contents.rs
index e3be350..c8d91f3 100644
--- a/tests/integration/config_invalid_secret_key_contents.rs
+++ b/tests/integration/config_invalid_secret_key_contents.rs
@@ -33,15 +33,27 @@ async fn config_invalid_secret_key_contents() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
         &temp_dir_path("bad_ssh_key"),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
         "--disable-http",
diff --git a/tests/integration/config_invalid_secret_key_path.rs b/tests/integration/config_invalid_secret_key_path.rs
index 96f8140..1007068 100644
--- a/tests/integration/config_invalid_secret_key_path.rs
+++ b/tests/integration/config_invalid_secret_key_path.rs
@@ -13,15 +13,27 @@ async fn config_invalid_secret_key_path() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
         "/",
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
         "--disable-http",
diff --git a/tests/integration/config_invalid_seed_file.rs b/tests/integration/config_invalid_seed_file.rs
index 38399b9..ed044a2 100644
--- a/tests/integration/config_invalid_seed_file.rs
+++ b/tests/integration/config_invalid_seed_file.rs
@@ -36,15 +36,30 @@ async fn config_invalid_seed_file() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
diff --git a/tests/integration/config_ipv6_blocklist.rs b/tests/integration/config_ipv6_blocklist.rs
index 3d5e87a..e4f8bee 100644
--- a/tests/integration/config_ipv6_blocklist.rs
+++ b/tests/integration/config_ipv6_blocklist.rs
@@ -19,15 +19,30 @@ async fn config_ipv6_blocklist() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=::",
         "--ssh-port=18022",
@@ -64,7 +79,8 @@ async fn config_ipv6_blocklist() {
 
     // 3. Start SSH client that will be allowed by IP allowlist
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/config_missing_seed_file.rs b/tests/integration/config_missing_seed_file.rs
index 2e2eb25..ae1ee5a 100644
--- a/tests/integration/config_missing_seed_file.rs
+++ b/tests/integration/config_missing_seed_file.rs
@@ -29,15 +29,30 @@ async fn config_missing_seed_file() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
diff --git a/tests/integration/config_no_write_permissions_for_admin_dir.rs b/tests/integration/config_no_write_permissions_for_admin_dir.rs
index f546086..ac70cf8 100644
--- a/tests/integration/config_no_write_permissions_for_admin_dir.rs
+++ b/tests/integration/config_no_write_permissions_for_admin_dir.rs
@@ -35,15 +35,27 @@ async fn config_no_write_permissions_for_admin_dir() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
         &temp_dir_path("unwritable_user_keys"),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
         "--disable-http",
diff --git a/tests/integration/config_no_write_permissions_for_certificates_dir.rs b/tests/integration/config_no_write_permissions_for_certificates_dir.rs
index de8c817..2aac773 100644
--- a/tests/integration/config_no_write_permissions_for_certificates_dir.rs
+++ b/tests/integration/config_no_write_permissions_for_certificates_dir.rs
@@ -35,15 +35,27 @@ async fn config_no_write_permissions_for_certificates_dir() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
         &temp_dir_path("unwritable_certificates"),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
         "--disable-http",
diff --git a/tests/integration/config_no_write_permissions_for_secret_key.rs b/tests/integration/config_no_write_permissions_for_secret_key.rs
index 959f47a..6fd415b 100644
--- a/tests/integration/config_no_write_permissions_for_secret_key.rs
+++ b/tests/integration/config_no_write_permissions_for_secret_key.rs
@@ -35,15 +35,27 @@ async fn config_no_write_permissions_for_secret_key() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
         &temp_dir_path("unwritable_ssh_file"),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
         "--disable-http",
diff --git a/tests/integration/config_no_write_permissions_for_users_dir.rs b/tests/integration/config_no_write_permissions_for_users_dir.rs
index e1820ab..8249ba9 100644
--- a/tests/integration/config_no_write_permissions_for_users_dir.rs
+++ b/tests/integration/config_no_write_permissions_for_users_dir.rs
@@ -37,13 +37,25 @@ async fn config_no_write_permissions_for_users_dir() {
         "--user-keys-directory",
         &temp_dir_path("unwritable_user_keys"),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
         "--disable-http",
diff --git a/tests/integration/connection_deny_load_balancing.rs b/tests/integration/connection_deny_load_balancing.rs
index 181f7f7..1b96349 100644
--- a/tests/integration/connection_deny_load_balancing.rs
+++ b/tests/integration/connection_deny_load_balancing.rs
@@ -23,15 +23,30 @@ async fn connection_deny_load_balancing() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -60,7 +75,8 @@ async fn connection_deny_load_balancing() {
     // 2. Start SSH clients that will take resources
     let key_1 = Arc::new(
         load_secret_key(
-            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/private_keys/key1"),
             None,
         )
         .expect("Missing file key1"),
@@ -163,7 +179,8 @@ async fn connection_deny_load_balancing() {
     // 3. Start SSH client that will be denied forwardings
     let key_2 = Arc::new(
         load_secret_key(
-            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/private_keys/key2"),
             None,
         )
         .expect("Missing file key2"),
diff --git a/tests/integration/connection_load_balancing.rs b/tests/integration/connection_load_balancing.rs
index 459f85a..f47ed34 100644
--- a/tests/integration/connection_load_balancing.rs
+++ b/tests/integration/connection_load_balancing.rs
@@ -23,15 +23,30 @@ async fn connection_load_balancing() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -58,7 +73,8 @@ async fn connection_load_balancing() {
 
     // 2. Start SSH clients that will be load-balanced
     let key_1 = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -85,7 +101,8 @@ async fn connection_load_balancing() {
         .await
         .expect("tcpip_forward failed");
     let key_2 = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key2"),
         None,
     )
     .expect("Missing file key2");
diff --git a/tests/integration/http_addressing_profanities_domain.rs b/tests/integration/http_addressing_profanities_domain.rs
index 109958c..dd107ca 100644
--- a/tests/integration/http_addressing_profanities_domain.rs
+++ b/tests/integration/http_addressing_profanities_domain.rs
@@ -34,15 +34,30 @@ async fn http_addressing_profanities_domain() {
         "sandhole",
         "--domain=safe.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -69,7 +84,8 @@ async fn http_addressing_profanities_domain() {
 
     // 2. Start SSH client that will be proxied with a profane name
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/http_addressing_profanities_no_root_domain.rs b/tests/integration/http_addressing_profanities_no_root_domain.rs
index 970b540..7dcedd2 100644
--- a/tests/integration/http_addressing_profanities_no_root_domain.rs
+++ b/tests/integration/http_addressing_profanities_no_root_domain.rs
@@ -20,15 +20,30 @@ async fn http_addressing_profanities_no_root_domain() {
         "sandhole",
         "--no-domain",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -55,7 +70,8 @@ async fn http_addressing_profanities_no_root_domain() {
 
     // 2. Start SSH client that will fail to proxied with a profane name
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/http_addressing_profanities_subdomain.rs b/tests/integration/http_addressing_profanities_subdomain.rs
index a738f08..8117a9f 100644
--- a/tests/integration/http_addressing_profanities_subdomain.rs
+++ b/tests/integration/http_addressing_profanities_subdomain.rs
@@ -33,15 +33,30 @@ async fn http_addressing_profanities_subdomain() {
         "sandhole",
         "--domain=fuck.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -68,7 +83,8 @@ async fn http_addressing_profanities_subdomain() {
 
     // 2. Start SSH client that will be proxied with a profane and a non-profane name
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/http_force_https_by_user.rs b/tests/integration/http_force_https_by_user.rs
index 38decf0..9997345 100644
--- a/tests/integration/http_force_https_by_user.rs
+++ b/tests/integration/http_force_https_by_user.rs
@@ -33,15 +33,30 @@ async fn http_force_https_by_user() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -67,7 +82,8 @@ async fn http_force_https_by_user() {
 
     // 2. Start SSH client that will set force-https
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -110,7 +126,8 @@ async fn http_force_https_by_user() {
 
     // 3. Start SSH client that will NOT set force-https
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -216,7 +233,8 @@ async fn http_force_https_by_user() {
 
     // 6. Create alias to the HTTP, to ensure that user-enforced HTTPS redirects don't apply there
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key2"),
         None,
     )
     .expect("Missing file key2");
diff --git a/tests/integration/http_pool_limit.rs b/tests/integration/http_pool_limit.rs
index 5927c57..9dad41e 100644
--- a/tests/integration/http_pool_limit.rs
+++ b/tests/integration/http_pool_limit.rs
@@ -32,15 +32,30 @@ async fn http_pool_limit() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -67,7 +82,8 @@ async fn http_pool_limit() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/http_pool_timeout.rs b/tests/integration/http_pool_timeout.rs
index eb356fc..ed90216 100644
--- a/tests/integration/http_pool_timeout.rs
+++ b/tests/integration/http_pool_timeout.rs
@@ -35,15 +35,30 @@ async fn http_pool_timeout() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -71,7 +86,8 @@ async fn http_pool_timeout() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/http_redirects.rs b/tests/integration/http_redirects.rs
index 00a2ea4..85b8687 100644
--- a/tests/integration/http_redirects.rs
+++ b/tests/integration/http_redirects.rs
@@ -31,15 +31,30 @@ async fn http_redirects() {
         "--domain=foobar.tld",
         "--domain-redirect=https://sandhole.com.br",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -66,7 +81,8 @@ async fn http_redirects() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/http_rewrite_host.rs b/tests/integration/http_rewrite_host.rs
index 525c226..1bc7655 100644
--- a/tests/integration/http_rewrite_host.rs
+++ b/tests/integration/http_rewrite_host.rs
@@ -36,15 +36,30 @@ async fn http_rewrite_host() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -71,7 +86,8 @@ async fn http_rewrite_host() {
 
     // 2. Start SSH client that will set a custom host
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/http_simultaneous_requests.rs b/tests/integration/http_simultaneous_requests.rs
index a164d96..0367f9a 100644
--- a/tests/integration/http_simultaneous_requests.rs
+++ b/tests/integration/http_simultaneous_requests.rs
@@ -32,15 +32,30 @@ async fn http_simultaneous_requests() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -66,7 +81,8 @@ async fn http_simultaneous_requests() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/http_timeout.rs b/tests/integration/http_timeout.rs
index 3816ec1..6877201 100644
--- a/tests/integration/http_timeout.rs
+++ b/tests/integration/http_timeout.rs
@@ -35,15 +35,30 @@ async fn http_timeout() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -70,7 +85,8 @@ async fn http_timeout() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -138,10 +154,10 @@ async fn http_timeout() {
     // 5. Idle after handshake to the HTTPS port of our proxy
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_bind_all_hostnames.rs b/tests/integration/https_bind_all_hostnames.rs
index 52cb019..15f8e46 100644
--- a/tests/integration/https_bind_all_hostnames.rs
+++ b/tests/integration/https_bind_all_hostnames.rs
@@ -36,15 +36,30 @@ async fn https_bind_all_hostnames() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -70,7 +85,8 @@ async fn https_bind_all_hostnames() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -100,10 +116,10 @@ async fn https_bind_all_hostnames() {
     // 3. Connect to the HTTPS port of our proxy
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_connect_ssh_on_https_port.rs b/tests/integration/https_connect_ssh_on_https_port.rs
index 828702f..f44586d 100644
--- a/tests/integration/https_connect_ssh_on_https_port.rs
+++ b/tests/integration/https_connect_ssh_on_https_port.rs
@@ -37,15 +37,30 @@ async fn https_connect_ssh_on_https_port() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -72,7 +87,8 @@ async fn https_connect_ssh_on_https_port() {
 
     // 2. Start SSH client that will connect via the HTTPS port
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -102,10 +118,10 @@ async fn https_connect_ssh_on_https_port() {
     // 3. Connect to the HTTPS port of our proxy
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_force_random_subdomains.rs b/tests/integration/https_force_random_subdomains.rs
index c25aa21..6ea5cc9 100644
--- a/tests/integration/https_force_random_subdomains.rs
+++ b/tests/integration/https_force_random_subdomains.rs
@@ -37,15 +37,30 @@ async fn https_force_random_subdomains() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -72,7 +87,8 @@ async fn https_force_random_subdomains() {
 
     // 2. Start SSH client that will be proxied via HTTPS
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -141,10 +157,10 @@ async fn https_force_random_subdomains() {
     // 3. Connect to the HTTPS port of our proxy
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_http11_fallback.rs b/tests/integration/https_http11_fallback.rs
index 78994a6..afb9de6 100644
--- a/tests/integration/https_http11_fallback.rs
+++ b/tests/integration/https_http11_fallback.rs
@@ -35,15 +35,30 @@ async fn https_http11_fallback() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -69,7 +84,8 @@ async fn https_http11_fallback() {
 
     // 2. Start SSH client that will be proxied via HTTP/2
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -99,10 +115,10 @@ async fn https_http11_fallback() {
     // 3. Connect to the HTTP/2 port of our proxy
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_http2.rs b/tests/integration/https_http2.rs
index 0df0142..9b006dc 100644
--- a/tests/integration/https_http2.rs
+++ b/tests/integration/https_http2.rs
@@ -38,15 +38,30 @@ async fn https_http2() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -72,7 +87,8 @@ async fn https_http2() {
 
     // 2. Start SSH client that will be proxied via HTTP/2
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -115,10 +131,10 @@ async fn https_http2() {
     // 3. Connect to the HTTP/2 port of our proxy
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_multi_stream_download.rs b/tests/integration/https_multi_stream_download.rs
index 792e087..994f338 100644
--- a/tests/integration/https_multi_stream_download.rs
+++ b/tests/integration/https_multi_stream_download.rs
@@ -47,15 +47,30 @@ async fn https_multi_stream_download() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -81,7 +96,8 @@ async fn https_multi_stream_download() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -126,10 +142,10 @@ async fn https_multi_stream_download() {
     // 3. Connect to the HTTPS port of our proxy with multiple streams
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_multi_stream_upload.rs b/tests/integration/https_multi_stream_upload.rs
index c31a738..0343a32 100644
--- a/tests/integration/https_multi_stream_upload.rs
+++ b/tests/integration/https_multi_stream_upload.rs
@@ -45,15 +45,30 @@ async fn https_multi_stream_upload() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -79,7 +94,8 @@ async fn https_multi_stream_upload() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -122,10 +138,10 @@ async fn https_multi_stream_upload() {
     // 3. Connect to the HTTPS port of our proxy with multiple streams
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_random_subdomains_with_fixed_seed.rs b/tests/integration/https_random_subdomains_with_fixed_seed.rs
index 74baa58..3cbe9c9 100644
--- a/tests/integration/https_random_subdomains_with_fixed_seed.rs
+++ b/tests/integration/https_random_subdomains_with_fixed_seed.rs
@@ -36,15 +36,30 @@ async fn https_random_subdomains_with_fixed_seed() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -73,7 +88,8 @@ async fn https_random_subdomains_with_fixed_seed() {
 
     // 2. Start SSH client that will be proxied via HTTPS
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -140,10 +156,10 @@ async fn https_random_subdomains_with_fixed_seed() {
     // 3. Connect to the HTTPS port of our proxy
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_random_subdomains_with_fixed_seed_file.rs b/tests/integration/https_random_subdomains_with_fixed_seed_file.rs
index f3699a8..4f2e9c4 100644
--- a/tests/integration/https_random_subdomains_with_fixed_seed_file.rs
+++ b/tests/integration/https_random_subdomains_with_fixed_seed_file.rs
@@ -60,15 +60,30 @@ async fn https_random_subdomains_with_fixed_seed_file() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -99,7 +114,8 @@ async fn https_random_subdomains_with_fixed_seed_file() {
 
     // 2. Start SSH client that will be proxied via HTTPS
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -166,10 +182,10 @@ async fn https_random_subdomains_with_fixed_seed_file() {
     // 3. Connect to the HTTPS port of our proxy
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_rate_limit_download.rs b/tests/integration/https_rate_limit_download.rs
index bc81c63..dba75d1 100644
--- a/tests/integration/https_rate_limit_download.rs
+++ b/tests/integration/https_rate_limit_download.rs
@@ -45,15 +45,30 @@ async fn https_rate_limit_download() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -81,7 +96,8 @@ async fn https_rate_limit_download() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -111,10 +127,10 @@ async fn https_rate_limit_download() {
     // 3. Connect to the HTTPS port of our proxy with out multiple streams
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_rate_limit_upload.rs b/tests/integration/https_rate_limit_upload.rs
index d757afd..ee67e40 100644
--- a/tests/integration/https_rate_limit_upload.rs
+++ b/tests/integration/https_rate_limit_upload.rs
@@ -40,15 +40,30 @@ async fn https_rate_limit_upload() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -76,7 +91,8 @@ async fn https_rate_limit_upload() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -106,10 +122,10 @@ async fn https_rate_limit_upload() {
     // 3. Connect to the HTTPS port of our proxy with out multiple streams
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_single_stream_download.rs b/tests/integration/https_single_stream_download.rs
index 4946036..5a77b06 100644
--- a/tests/integration/https_single_stream_download.rs
+++ b/tests/integration/https_single_stream_download.rs
@@ -47,15 +47,30 @@ async fn https_single_stream_download() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -81,7 +96,8 @@ async fn https_single_stream_download() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -127,10 +143,10 @@ async fn https_single_stream_download() {
     // 3. Connect to the HTTPS port of our proxy with a single stream
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/https_single_stream_upload.rs b/tests/integration/https_single_stream_upload.rs
index 5ffc51a..ff2a649 100644
--- a/tests/integration/https_single_stream_upload.rs
+++ b/tests/integration/https_single_stream_upload.rs
@@ -45,15 +45,30 @@ async fn https_single_stream_upload() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -79,7 +94,8 @@ async fn https_single_stream_upload() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -123,10 +139,10 @@ async fn https_single_stream_upload() {
     // 3. Connect to the HTTPS port of our proxy with a single stream
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
diff --git a/tests/integration/ip_error_on_repeated_cidr.rs b/tests/integration/ip_error_on_repeated_cidr.rs
index 8d9ac26..818f617 100644
--- a/tests/integration/ip_error_on_repeated_cidr.rs
+++ b/tests/integration/ip_error_on_repeated_cidr.rs
@@ -21,15 +21,30 @@ async fn ip_error_on_repeated_cidr() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -55,7 +70,8 @@ async fn ip_error_on_repeated_cidr() {
 
     // 2. Start SSH client that will fail to set the same IP allowlist and blocklist
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/ipv6_blocklist_by_user.rs b/tests/integration/ipv6_blocklist_by_user.rs
index 6b0e8c8..c61dd45 100644
--- a/tests/integration/ipv6_blocklist_by_user.rs
+++ b/tests/integration/ipv6_blocklist_by_user.rs
@@ -32,15 +32,30 @@ async fn ipv6_blocklist_by_user() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=::",
         "--ssh-port=18022",
@@ -66,7 +81,8 @@ async fn ipv6_blocklist_by_user() {
 
     // 2. Start SSH client that will set ip-allowlist and ip-blocklist
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -171,7 +187,8 @@ async fn ipv6_blocklist_by_user() {
 
     // 5. Start SSH client that will be blocked from aliasing to the service
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key2"),
         None,
     )
     .expect("Missing file key2");
@@ -203,7 +220,8 @@ async fn ipv6_blocklist_by_user() {
 
     // 6. Start SSH client that will be allowed to alias to the service
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key2"),
         None,
     )
     .expect("Missing file key2");
diff --git a/tests/integration/lib_already_bound_ports.rs b/tests/integration/lib_already_bound_ports.rs
index e943934..e9db69b 100644
--- a/tests/integration/lib_already_bound_ports.rs
+++ b/tests/integration/lib_already_bound_ports.rs
@@ -25,15 +25,30 @@ async fn lib_already_bound_ports() {
                 "sandhole",
                 "--domain=foobar.tld",
                 "--user-keys-directory",
-                concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+                &(format!(
+                    "{}/tests/data/user_keys",
+                    std::env::var("CARGO_MANIFEST_DIR").unwrap()
+                )),
                 "--admin-keys-directory",
-                concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+                &(format!(
+                    "{}/tests/data/admin_keys",
+                    std::env::var("CARGO_MANIFEST_DIR").unwrap()
+                )),
                 "--certificates-directory",
-                concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+                &(format!(
+                    "{}/tests/data/certificates",
+                    std::env::var("CARGO_MANIFEST_DIR").unwrap()
+                )),
                 "--private-key-file",
-                concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+                &(format!(
+                    "{}/tests/data/server_keys/ssh",
+                    std::env::var("CARGO_MANIFEST_DIR").unwrap()
+                )),
                 "--acme-cache-directory",
-                concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+                &(format!(
+                    "{}/tests/data/acme_cache",
+                    std::env::var("CARGO_MANIFEST_DIR").unwrap()
+                )),
                 "--disable-directory-creation",
                 "--listen-address=127.0.0.1",
                 "--ssh-port=18022",
diff --git a/tests/integration/lib_close_with_sigint.rs b/tests/integration/lib_close_with_sigint.rs
index 9f7d557..765acdf 100644
--- a/tests/integration/lib_close_with_sigint.rs
+++ b/tests/integration/lib_close_with_sigint.rs
@@ -23,15 +23,30 @@ async fn lib_close_with_sigint() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
diff --git a/tests/integration/lib_close_with_sigterm.rs b/tests/integration/lib_close_with_sigterm.rs
index ee11c07..243efb8 100644
--- a/tests/integration/lib_close_with_sigterm.rs
+++ b/tests/integration/lib_close_with_sigterm.rs
@@ -23,15 +23,30 @@ async fn lib_close_with_sigterm() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
diff --git a/tests/integration/lib_configure_from_scratch.rs b/tests/integration/lib_configure_from_scratch.rs
index 30f454c..ff81869 100644
--- a/tests/integration/lib_configure_from_scratch.rs
+++ b/tests/integration/lib_configure_from_scratch.rs
@@ -115,7 +115,8 @@ async fn lib_configure_from_scratch() {
 
     // 3. Start SSH client that is not recognized
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -144,10 +145,8 @@ async fn lib_configure_from_scratch() {
 
     // 4. Add key for SSH client that will be recognized
     fs::copy(
-        concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/user_keys/keys_1_2.pub"
-        ),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/user_keys/keys_1_2.pub"),
         temp_dir.join("user_keys/keys_1_2.pub"),
     )
     .await
@@ -155,7 +154,8 @@ async fn lib_configure_from_scratch() {
     // Wait for debounce on user pubkeys watcher (1s) + time to process the file
     sleep(Duration::from_millis(4_000)).await;
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key2"),
         None,
     )
     .expect("Missing file key2");
diff --git a/tests/integration/quota_maximum_per_user.rs b/tests/integration/quota_maximum_per_user.rs
index dcfa2b9..b578cde 100644
--- a/tests/integration/quota_maximum_per_user.rs
+++ b/tests/integration/quota_maximum_per_user.rs
@@ -30,15 +30,30 @@ async fn quota_maximum_per_user() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -66,7 +81,8 @@ async fn quota_maximum_per_user() {
     // 2. Start SSH client that will reach quota
     let key_1 = Arc::new(
         load_secret_key(
-            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/private_keys/key1"),
             None,
         )
         .expect("Missing file key1"),
@@ -141,7 +157,8 @@ async fn quota_maximum_per_user() {
     // 5. Admin user doesn't have quota limit
     let admin_key = Arc::new(
         load_secret_key(
-            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/admin"),
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/private_keys/admin"),
             None,
         )
         .expect("Missing file admin"),
diff --git a/tests/integration/sni_aliasing.rs b/tests/integration/sni_aliasing.rs
index cd0d938..4d7d2c6 100644
--- a/tests/integration/sni_aliasing.rs
+++ b/tests/integration/sni_aliasing.rs
@@ -33,16 +33,6 @@ use tower::Service;
 
 use crate::common::SandholeHandle;
 
-// Certificate for sandhole.com.br with custom CA
-const TLS_CERTIFICATE: &str = include_str!(concat!(
-    env!("CARGO_MANIFEST_DIR"),
-    "/tests/data/custom_certificate/fullchain.pem"
-));
-const TLS_KEY: &str = include_str!(concat!(
-    env!("CARGO_MANIFEST_DIR"),
-    "/tests/data/custom_certificate/privkey.pem"
-));
-
 /// This test ensures that local forwarding works for SNI proxies.
 #[test_log::test(tokio::test(flavor = "multi_thread"))]
 async fn sni_aliasing() {
@@ -51,15 +41,30 @@ async fn sni_aliasing() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -85,7 +90,8 @@ async fn sni_aliasing() {
 
     // 2. Start SSH client that will be proxied with SNI
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -133,10 +139,10 @@ async fn sni_aliasing() {
     // 3. Alias to our SNI proxy
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
@@ -251,10 +257,18 @@ impl russh::client::Handler for SshClient {
         tokio::spawn(async move {
             let router = Router::new().route("/sni-proxy", get(async || "Hello from SNI proxy!"));
             let service = service_fn(move |req: Request<Incoming>| router.clone().call(req));
-            let certs = CertificateDer::pem_slice_iter(TLS_CERTIFICATE.as_bytes())
-                .collect::<Result<Vec<_>, _>>()
-                .unwrap();
-            let key = PrivateKeyDer::from_pem_slice(TLS_KEY.as_bytes()).unwrap();
+            let certs = CertificateDer::pem_file_iter(
+                std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/custom_certificate/fullchain.pem"),
+            )
+            .unwrap()
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
+            let key = PrivateKeyDer::from_pem_file(
+                std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/custom_certificate/privkey.pem"),
+            )
+            .unwrap();
             let config = rustls::ServerConfig::builder()
                 .with_no_client_auth()
                 .with_single_cert(certs, key)
diff --git a/tests/integration/sni_aliasing_timeout.rs b/tests/integration/sni_aliasing_timeout.rs
index df2a638..cd0a8ad 100644
--- a/tests/integration/sni_aliasing_timeout.rs
+++ b/tests/integration/sni_aliasing_timeout.rs
@@ -32,16 +32,6 @@ use tower::Service;
 
 use crate::common::SandholeHandle;
 
-// Certificate for sandhole.com.br with custom CA
-const TLS_CERTIFICATE: &str = include_str!(concat!(
-    env!("CARGO_MANIFEST_DIR"),
-    "/tests/data/custom_certificate/fullchain.pem"
-));
-const TLS_KEY: &str = include_str!(concat!(
-    env!("CARGO_MANIFEST_DIR"),
-    "/tests/data/custom_certificate/privkey.pem"
-));
-
 /// This test ensures that an aliased SNI connection times out after a certain
 /// time configured by the server.
 #[test_log::test(tokio::test(flavor = "multi_thread"))]
@@ -51,15 +41,30 @@ async fn sni_aliasing_timeout() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -86,7 +91,8 @@ async fn sni_aliasing_timeout() {
 
     // 2. Start SSH client that will be proxied with SNI
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -134,10 +140,10 @@ async fn sni_aliasing_timeout() {
     // 3. Alias to our SNI proxy
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
@@ -240,10 +246,18 @@ impl russh::client::Handler for SshClient {
                 }),
             );
             let service = service_fn(move |req: Request<Incoming>| router.clone().call(req));
-            let certs = CertificateDer::pem_slice_iter(TLS_CERTIFICATE.as_bytes())
-                .collect::<Result<Vec<_>, _>>()
-                .unwrap();
-            let key = PrivateKeyDer::from_pem_slice(TLS_KEY.as_bytes()).unwrap();
+            let certs = CertificateDer::pem_file_iter(
+                std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/custom_certificate/fullchain.pem"),
+            )
+            .unwrap()
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
+            let key = PrivateKeyDer::from_pem_file(
+                std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/custom_certificate/privkey.pem"),
+            )
+            .unwrap();
             let config = rustls::ServerConfig::builder()
                 .with_no_client_auth()
                 .with_single_cert(certs, key)
diff --git a/tests/integration/sni_proxy.rs b/tests/integration/sni_proxy.rs
index e0da496..0f5c355 100644
--- a/tests/integration/sni_proxy.rs
+++ b/tests/integration/sni_proxy.rs
@@ -30,16 +30,6 @@ use tower::Service;
 
 use crate::common::SandholeHandle;
 
-// Certificate for sandhole.com.br with custom CA
-const TLS_CERTIFICATE: &str = include_str!(concat!(
-    env!("CARGO_MANIFEST_DIR"),
-    "/tests/data/custom_certificate/fullchain.pem"
-));
-const TLS_KEY: &str = include_str!(concat!(
-    env!("CARGO_MANIFEST_DIR"),
-    "/tests/data/custom_certificate/privkey.pem"
-));
-
 /// This test ensures that SNI proxies can be connected to.
 #[test_log::test(tokio::test(flavor = "multi_thread"))]
 async fn sni_proxy() {
@@ -48,15 +38,30 @@ async fn sni_proxy() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -82,7 +87,8 @@ async fn sni_proxy() {
 
     // 2. Start SSH client that will be proxied with SNI
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -125,10 +131,10 @@ async fn sni_proxy() {
     // 3. Connect to the SNI-protected port of our proxy
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
@@ -214,10 +220,18 @@ impl russh::client::Handler for SshClient {
         tokio::spawn(async move {
             let router = Router::new().route("/sni-proxy", get(async || "Hello from SNI proxy!"));
             let service = service_fn(move |req: Request<Incoming>| router.clone().call(req));
-            let certs = CertificateDer::pem_slice_iter(TLS_CERTIFICATE.as_bytes())
-                .collect::<Result<Vec<_>, _>>()
-                .unwrap();
-            let key = PrivateKeyDer::from_pem_slice(TLS_KEY.as_bytes()).unwrap();
+            let certs = CertificateDer::pem_file_iter(
+                std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/custom_certificate/fullchain.pem"),
+            )
+            .unwrap()
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
+            let key = PrivateKeyDer::from_pem_file(
+                std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/custom_certificate/privkey.pem"),
+            )
+            .unwrap();
             let config = rustls::ServerConfig::builder()
                 .with_no_client_auth()
                 .with_single_cert(certs, key)
diff --git a/tests/integration/sni_timeout.rs b/tests/integration/sni_timeout.rs
index 33b5ee2..5fe56b4 100644
--- a/tests/integration/sni_timeout.rs
+++ b/tests/integration/sni_timeout.rs
@@ -28,16 +28,6 @@ use tower::Service;
 
 use crate::common::SandholeHandle;
 
-// Certificate for sandhole.com.br with custom CA
-const TLS_CERTIFICATE: &str = include_str!(concat!(
-    env!("CARGO_MANIFEST_DIR"),
-    "/tests/data/custom_certificate/fullchain.pem"
-));
-const TLS_KEY: &str = include_str!(concat!(
-    env!("CARGO_MANIFEST_DIR"),
-    "/tests/data/custom_certificate/privkey.pem"
-));
-
 /// This test ensures that an SNI connection times out after a certain time
 /// configured by the server.
 #[test_log::test(tokio::test(flavor = "multi_thread"))]
@@ -47,15 +37,30 @@ async fn sni_timeout() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -82,7 +87,8 @@ async fn sni_timeout() {
 
     // 2. Start SSH client that will be proxied with SNI
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -125,10 +131,10 @@ async fn sni_timeout() {
     // 3. Connect to the SNI-protected port of our proxy
     let mut root_store = RootCertStore::empty();
     root_store.add_parsable_certificates(
-        CertificateDer::pem_file_iter(concat!(
-            env!("CARGO_MANIFEST_DIR"),
-            "/tests/data/ca/rootCA.pem"
-        ))
+        CertificateDer::pem_file_iter(
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/ca/rootCA.pem"),
+        )
         .and_then(|iter| iter.collect::<Result<Vec<_>, _>>())
         .expect("Failed to parse certificates"),
     );
@@ -194,10 +200,18 @@ impl russh::client::Handler for SshClient {
                 }),
             );
             let service = service_fn(move |req: Request<Incoming>| router.clone().call(req));
-            let certs = CertificateDer::pem_slice_iter(TLS_CERTIFICATE.as_bytes())
-                .collect::<Result<Vec<_>, _>>()
-                .unwrap();
-            let key = PrivateKeyDer::from_pem_slice(TLS_KEY.as_bytes()).unwrap();
+            let certs = CertificateDer::pem_file_iter(
+                std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/custom_certificate/fullchain.pem"),
+            )
+            .unwrap()
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
+            let key = PrivateKeyDer::from_pem_file(
+                std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                    .join("tests/data/custom_certificate/privkey.pem"),
+            )
+            .unwrap();
             let config = rustls::ServerConfig::builder()
                 .with_no_client_auth()
                 .with_single_cert(certs, key)
diff --git a/tests/integration/ssh_client_timeout.rs b/tests/integration/ssh_client_timeout.rs
index bc13779..cbdab55 100644
--- a/tests/integration/ssh_client_timeout.rs
+++ b/tests/integration/ssh_client_timeout.rs
@@ -28,15 +28,30 @@ async fn ssh_client_timeout() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -65,7 +80,8 @@ async fn ssh_client_timeout() {
     // 2. Start SSH client that should stay alive through keepalive timeout
     let key = Arc::new(
         load_secret_key(
-            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/private_keys/key1"),
             None,
         )
         .expect("Missing file key1"),
diff --git a/tests/integration/ssh_ignore_data_on_non_session_channels.rs b/tests/integration/ssh_ignore_data_on_non_session_channels.rs
index 1cbcae9..cd825a6 100644
--- a/tests/integration/ssh_ignore_data_on_non_session_channels.rs
+++ b/tests/integration/ssh_ignore_data_on_non_session_channels.rs
@@ -25,15 +25,30 @@ async fn ssh_ignore_data_on_non_session_channels() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -60,7 +75,8 @@ async fn ssh_ignore_data_on_non_session_channels() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/ssh_invalid_exec_commands.rs b/tests/integration/ssh_invalid_exec_commands.rs
index e18cdd7..006ad1c 100644
--- a/tests/integration/ssh_invalid_exec_commands.rs
+++ b/tests/integration/ssh_invalid_exec_commands.rs
@@ -21,15 +21,30 @@ async fn ssh_invalid_exec_commands() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -125,7 +140,8 @@ async fn ssh_invalid_exec_commands() {
         vec!["unknown"],
     ] {
         let key = load_secret_key(
-            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/private_keys/key1"),
             None,
         )
         .expect("Missing file key1");
@@ -175,7 +191,8 @@ async fn ssh_invalid_exec_commands() {
         vec!["admin", "admin"],
     ] {
         let key = load_secret_key(
-            concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/admin"),
+            std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+                .join("tests/data/private_keys/admin"),
             None,
         )
         .expect("Missing file admin");
diff --git a/tests/integration/ssh_no_valid_forwarding.rs b/tests/integration/ssh_no_valid_forwarding.rs
index c722daa..d3c0318 100644
--- a/tests/integration/ssh_no_valid_forwarding.rs
+++ b/tests/integration/ssh_no_valid_forwarding.rs
@@ -19,15 +19,30 @@ async fn ssh_no_valid_forwarding() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -53,7 +68,8 @@ async fn ssh_no_valid_forwarding() {
 
     // 2. Start SSH client that will fail to local forward
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/ssh_proxy_jump.rs b/tests/integration/ssh_proxy_jump.rs
index 930f7e1..08c3ca6 100644
--- a/tests/integration/ssh_proxy_jump.rs
+++ b/tests/integration/ssh_proxy_jump.rs
@@ -34,15 +34,30 @@ async fn ssh_proxy_jump() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -68,7 +83,8 @@ async fn ssh_proxy_jump() {
 
     // 2. Start SSH client that will be proxied via HTTPS
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -162,7 +178,8 @@ async fn ssh_proxy_jump() {
 
     // 4. Connect to the SSH port of our proxy with known user
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key2"),
         None,
     )
     .expect("Missing file key2");
diff --git a/tests/integration/ssh_rate_limit_download.rs b/tests/integration/ssh_rate_limit_download.rs
index fb16dd4..d22d723 100644
--- a/tests/integration/ssh_rate_limit_download.rs
+++ b/tests/integration/ssh_rate_limit_download.rs
@@ -36,15 +36,30 @@ async fn ssh_rate_limit_download() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -72,7 +87,8 @@ async fn ssh_rate_limit_download() {
 
     // 2. Start SSH client that will be proxied via HTTPS
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/ssh_rate_limit_upload.rs b/tests/integration/ssh_rate_limit_upload.rs
index 5076fb3..2d599a1 100644
--- a/tests/integration/ssh_rate_limit_upload.rs
+++ b/tests/integration/ssh_rate_limit_upload.rs
@@ -36,15 +36,30 @@ async fn ssh_rate_limit_upload() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -72,7 +87,8 @@ async fn ssh_rate_limit_upload() {
 
     // 2. Start SSH client that will be proxied via HTTPS
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/ssh_require_alias_for_low_ports.rs b/tests/integration/ssh_require_alias_for_low_ports.rs
index 3a7e28b..963aa37 100644
--- a/tests/integration/ssh_require_alias_for_low_ports.rs
+++ b/tests/integration/ssh_require_alias_for_low_ports.rs
@@ -19,15 +19,30 @@ async fn ssh_require_alias_for_low_ports() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -53,7 +68,8 @@ async fn ssh_require_alias_for_low_ports() {
 
     // 2. Start SSH client that will fail to alias to localhost
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/ssh_single_data_channel.rs b/tests/integration/ssh_single_data_channel.rs
index a489f2e..18d6337 100644
--- a/tests/integration/ssh_single_data_channel.rs
+++ b/tests/integration/ssh_single_data_channel.rs
@@ -19,15 +19,30 @@ async fn ssh_single_data_channel() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -53,7 +68,8 @@ async fn ssh_single_data_channel() {
 
     // 2. Start SSH client that will fail to alias to localhost
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/tcp_allow_requested_ports.rs b/tests/integration/tcp_allow_requested_ports.rs
index f086634..0e876c6 100644
--- a/tests/integration/tcp_allow_requested_ports.rs
+++ b/tests/integration/tcp_allow_requested_ports.rs
@@ -26,15 +26,30 @@ async fn tcp_allow_requested_ports() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -61,7 +76,8 @@ async fn tcp_allow_requested_ports() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -146,7 +162,8 @@ async fn tcp_allow_requested_ports() {
 
     // 5. Local-forward the TCP port for known user
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key2"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key2"),
         None,
     )
     .expect("Missing file key2");
diff --git a/tests/integration/tcp_assign_random_port_0.rs b/tests/integration/tcp_assign_random_port_0.rs
index b2fe389..0f9c671 100644
--- a/tests/integration/tcp_assign_random_port_0.rs
+++ b/tests/integration/tcp_assign_random_port_0.rs
@@ -24,15 +24,30 @@ async fn tcp_assign_random_port_0() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -59,7 +74,8 @@ async fn tcp_assign_random_port_0() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/tcp_bind_random_ports.rs b/tests/integration/tcp_bind_random_ports.rs
index 7bdbf4b..8fc643f 100644
--- a/tests/integration/tcp_bind_random_ports.rs
+++ b/tests/integration/tcp_bind_random_ports.rs
@@ -23,15 +23,30 @@ async fn tcp_bind_random_ports() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -57,7 +72,8 @@ async fn tcp_bind_random_ports() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/tcp_fail_to_bind_port_if_taken.rs b/tests/integration/tcp_fail_to_bind_port_if_taken.rs
index 6cd1f43..0d37bbf 100644
--- a/tests/integration/tcp_fail_to_bind_port_if_taken.rs
+++ b/tests/integration/tcp_fail_to_bind_port_if_taken.rs
@@ -25,15 +25,30 @@ async fn tcp_fail_to_bind_port_if_taken() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -60,7 +75,8 @@ async fn tcp_fail_to_bind_port_if_taken() {
 
     // 3. Start SSH client that will fail to bind to taken port
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/tcp_multi_stream_download.rs b/tests/integration/tcp_multi_stream_download.rs
index 0effd84..c98f7d7 100644
--- a/tests/integration/tcp_multi_stream_download.rs
+++ b/tests/integration/tcp_multi_stream_download.rs
@@ -29,15 +29,30 @@ async fn tcp_multi_stream_download() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -64,7 +79,8 @@ async fn tcp_multi_stream_download() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/tcp_multi_stream_upload.rs b/tests/integration/tcp_multi_stream_upload.rs
index f7bf85a..f300fe0 100644
--- a/tests/integration/tcp_multi_stream_upload.rs
+++ b/tests/integration/tcp_multi_stream_upload.rs
@@ -29,15 +29,30 @@ async fn tcp_multi_stream_upload() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -64,7 +79,8 @@ async fn tcp_multi_stream_upload() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/tcp_no_valid_forwarding.rs b/tests/integration/tcp_no_valid_forwarding.rs
index 0512410..fc9b50b 100644
--- a/tests/integration/tcp_no_valid_forwarding.rs
+++ b/tests/integration/tcp_no_valid_forwarding.rs
@@ -19,15 +19,30 @@ async fn tcp_no_valid_forwarding() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -53,7 +68,8 @@ async fn tcp_no_valid_forwarding() {
 
     // 2. Start SSH client that will fail to local forward
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/tcp_pool_timeout.rs b/tests/integration/tcp_pool_timeout.rs
index bcc462a..0fe816b 100644
--- a/tests/integration/tcp_pool_timeout.rs
+++ b/tests/integration/tcp_pool_timeout.rs
@@ -27,15 +27,30 @@ async fn tcp_pool_timeout() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -63,7 +78,8 @@ async fn tcp_pool_timeout() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/tcp_rate_limit_download.rs b/tests/integration/tcp_rate_limit_download.rs
index 69cfff2..fcab972 100644
--- a/tests/integration/tcp_rate_limit_download.rs
+++ b/tests/integration/tcp_rate_limit_download.rs
@@ -27,15 +27,30 @@ async fn tcp_rate_limit_download() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -64,7 +79,8 @@ async fn tcp_rate_limit_download() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/tcp_rate_limit_upload.rs b/tests/integration/tcp_rate_limit_upload.rs
index e6bd669..9526386 100644
--- a/tests/integration/tcp_rate_limit_upload.rs
+++ b/tests/integration/tcp_rate_limit_upload.rs
@@ -26,15 +26,30 @@ async fn tcp_rate_limit_upload() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -63,7 +78,8 @@ async fn tcp_rate_limit_upload() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/tcp_reject_low_ports.rs b/tests/integration/tcp_reject_low_ports.rs
index 624e233..65f4b56 100644
--- a/tests/integration/tcp_reject_low_ports.rs
+++ b/tests/integration/tcp_reject_low_ports.rs
@@ -22,15 +22,30 @@ async fn tcp_reject_low_ports() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -57,7 +72,8 @@ async fn tcp_reject_low_ports() {
 
     // 2. Start SSH client that will fail to bind
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/tcp_reject_port_above_max.rs b/tests/integration/tcp_reject_port_above_max.rs
index b024b9e..4331efa 100644
--- a/tests/integration/tcp_reject_port_above_max.rs
+++ b/tests/integration/tcp_reject_port_above_max.rs
@@ -23,15 +23,30 @@ async fn tcp_reject_port_above_max() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -58,7 +73,8 @@ async fn tcp_reject_port_above_max() {
 
     // 2. Start SSH client that will fail to bind
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -98,7 +114,8 @@ async fn tcp_reject_port_above_max() {
 
     // 3. Start SSH client that will fail to cancel a remote forwarding
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -131,7 +148,8 @@ async fn tcp_reject_port_above_max() {
 
     // 4. Start SSH clients that will fail to local forward an invalid port
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
@@ -162,7 +180,8 @@ async fn tcp_reject_port_above_max() {
     );
     assert!(session.is_closed());
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/tcp_timeout.rs b/tests/integration/tcp_timeout.rs
index 1b4cbc6..57e32e4 100644
--- a/tests/integration/tcp_timeout.rs
+++ b/tests/integration/tcp_timeout.rs
@@ -24,15 +24,30 @@ async fn tcp_timeout() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -59,7 +74,8 @@ async fn tcp_timeout() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/websocket_connection.rs b/tests/integration/websocket_connection.rs
index a576922..9549244 100644
--- a/tests/integration/websocket_connection.rs
+++ b/tests/integration/websocket_connection.rs
@@ -35,15 +35,30 @@ async fn websocket_connection() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -69,7 +84,8 @@ async fn websocket_connection() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");
diff --git a/tests/integration/websocket_timeout.rs b/tests/integration/websocket_timeout.rs
index 8289c77..d981cac 100644
--- a/tests/integration/websocket_timeout.rs
+++ b/tests/integration/websocket_timeout.rs
@@ -36,15 +36,30 @@ async fn websocket_timeout() {
         "sandhole",
         "--domain=foobar.tld",
         "--user-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/user_keys"),
+        &(format!(
+            "{}/tests/data/user_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--admin-keys-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/admin_keys"),
+        &(format!(
+            "{}/tests/data/admin_keys",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--certificates-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/certificates"),
+        &(format!(
+            "{}/tests/data/certificates",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--private-key-file",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/server_keys/ssh"),
+        &(format!(
+            "{}/tests/data/server_keys/ssh",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--acme-cache-directory",
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/acme_cache"),
+        &(format!(
+            "{}/tests/data/acme_cache",
+            std::env::var("CARGO_MANIFEST_DIR").unwrap()
+        )),
         "--disable-directory-creation",
         "--listen-address=127.0.0.1",
         "--ssh-port=18022",
@@ -70,7 +85,8 @@ async fn websocket_timeout() {
 
     // 2. Start SSH client that will be proxied
     let key = load_secret_key(
-        concat!(env!("CARGO_MANIFEST_DIR"), "/tests/data/private_keys/key1"),
+        std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("tests/data/private_keys/key1"),
         None,
     )
     .expect("Missing file key1");