diff --git a/edgelet/edgelet-docker/src/config.rs b/edgelet/edgelet-docker/src/config.rs
index 5617786a79f..27110f45ddf 100644
--- a/edgelet/edgelet-docker/src/config.rs
+++ b/edgelet/edgelet-docker/src/config.rs
@@ -92,15 +92,14 @@ mod tests {
     use super::*;
 
     #[test]
-    #[should_panic]
     fn empty_image_fails() {
-        DockerConfig::new("".to_string(), ContainerCreateBody::new(), None).unwrap();
+        let _ = DockerConfig::new("".to_string(), ContainerCreateBody::new(), None).unwrap_err();
     }
 
     #[test]
-    #[should_panic]
     fn white_space_image_fails() {
-        DockerConfig::new("    ".to_string(), ContainerCreateBody::new(), None).unwrap();
+        let _ =
+            DockerConfig::new("    ".to_string(), ContainerCreateBody::new(), None).unwrap_err();
     }
 
     #[test]
diff --git a/edgelet/edgelet-docker/src/module.rs b/edgelet/edgelet-docker/src/module.rs
index fdd278c18e8..8264592ecb3 100644
--- a/edgelet/edgelet-docker/src/module.rs
+++ b/edgelet/edgelet-docker/src/module.rs
@@ -242,25 +242,23 @@ mod tests {
     }
 
     #[test]
-    #[should_panic]
     fn empty_name_fails() {
-        let _docker_module = DockerModule::new(
+        let _ = DockerModule::new(
             create_api_client("boo"),
             "".to_string(),
             DockerConfig::new("ubuntu".to_string(), ContainerCreateBody::new(), None).unwrap(),
         )
-        .unwrap();
+        .unwrap_err();
     }
 
     #[test]
-    #[should_panic]
     fn white_space_name_fails() {
-        let _docker_module = DockerModule::new(
+        let _ = DockerModule::new(
             create_api_client("boo"),
             "     ".to_string(),
             DockerConfig::new("ubuntu".to_string(), ContainerCreateBody::new(), None).unwrap(),
         )
-        .unwrap();
+        .unwrap_err();
     }
 
     fn get_inputs() -> Vec<(&'static str, i64, ModuleStatus)> {
diff --git a/edgelet/edgelet-docker/src/runtime.rs b/edgelet/edgelet-docker/src/runtime.rs
index e5f75b83353..55304da57e3 100644
--- a/edgelet/edgelet-docker/src/runtime.rs
+++ b/edgelet/edgelet-docker/src/runtime.rs
@@ -972,30 +972,32 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "URL does not have a recognized scheme")]
     fn invalid_uri_prefix_fails() {
         let settings = make_settings(Some(json!({
             "moby_runtime": {
                 "uri": "foo:///this/is/not/valid"
             }
         })));
-        let _runtime = DockerModuleRuntime::make_runtime(settings, provisioning_result(), crypto())
+        let err = DockerModuleRuntime::make_runtime(settings, provisioning_result(), crypto())
             .wait()
-            .unwrap();
+            .unwrap_err();
+        assert!(err
+            .to_string()
+            .contains("URL does not have a recognized scheme"));
     }
 
     #[cfg(unix)]
     #[test]
-    #[should_panic(expected = "Socket file could not be found")]
     fn invalid_uds_path_fails() {
         let settings = make_settings(Some(json!({
             "moby_runtime": {
                 "uri": "unix:///this/file/does/not/exist"
             }
         })));
-        let _runtime = DockerModuleRuntime::make_runtime(settings, provisioning_result(), crypto())
+        let err = DockerModuleRuntime::make_runtime(settings, provisioning_result(), crypto())
             .wait()
-            .unwrap();
+            .unwrap_err();
+        assert!(err.to_string().contains("Socket file could not be found"));
     }
 
     #[test]
diff --git a/edgelet/edgelet-docker/tests/runtime.rs b/edgelet/edgelet-docker/tests/runtime.rs
index d4a597056e8..7d5dbc44131 100644
--- a/edgelet/edgelet-docker/tests/runtime.rs
+++ b/edgelet/edgelet-docker/tests/runtime.rs
@@ -9,7 +9,6 @@ use std::sync::{Arc, RwLock};
 use std::time::Duration;
 
 use config::{Config, File, FileFormat};
-#[cfg(unix)]
 use failure::Fail;
 use futures::future;
 use futures::prelude::*;
@@ -20,11 +19,9 @@ use serde_json::{self, json, Value as JsonValue};
 use typed_headers::{mime, ContentLength, ContentType, HeaderMapExt};
 use url::form_urlencoded::parse as parse_query;
 
-#[cfg(unix)]
-use docker::models::AuthConfig;
 use docker::models::{
-    ContainerCreateBody, ContainerHostConfig, ContainerNetworkSettings, ContainerSummary,
-    HostConfig, HostConfigPortBindings, ImageDeleteResponseItem, NetworkConfig,
+    AuthConfig, ContainerCreateBody, ContainerHostConfig, ContainerNetworkSettings,
+    ContainerSummary, HostConfig, HostConfigPortBindings, ImageDeleteResponseItem, NetworkConfig,
 };
 
 use edgelet_core::{
@@ -37,15 +34,13 @@ use edgelet_test_utils::crypto::TestHsm;
 use edgelet_test_utils::web::{
     make_req_dispatcher, HttpMethod, RequestHandler, RequestPath, ResponseFuture,
 };
-use edgelet_test_utils::{get_unused_tcp_port, routes, run_tcp_server};
+use edgelet_test_utils::{routes, run_tcp_server};
 use hyper::Error as HyperError;
 use provisioning::{ProvisioningResult, ReprovisioningStatus};
 
 const IMAGE_NAME: &str = "nginx:latest";
 
-#[cfg(unix)]
 const INVALID_IMAGE_NAME: &str = "invalidname:latest";
-#[cfg(unix)]
 const INVALID_IMAGE_HOST: &str = "invalidhost.com/nginx:latest";
 
 fn make_settings(merge_json: Option<JsonValue>) -> Settings {
@@ -188,7 +183,6 @@ fn default_network_handler(
     make_req_dispatcher(dispatch_table, Box::new(not_found_handler))
 }
 
-#[cfg(unix)]
 #[allow(clippy::needless_pass_by_value)]
 fn invalid_image_name_pull_handler(req: Request<Body>) -> ResponseFuture {
     // verify that path is /images/create and that the "fromImage" query
@@ -226,26 +220,20 @@ fn invalid_image_name_pull_handler(req: Request<Body>) -> ResponseFuture {
     Box::new(future::ok(response))
 }
 
-// This test is super flaky on Windows for some reason. It keeps occassionally
-// failing on Windows with error 10054 which means the server keeps dropping the
-// socket for no reason apparently.
-#[cfg(unix)]
 #[test]
 fn image_pull_with_invalid_image_name_fails() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         POST "/images/create" => invalid_image_name_pull_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -297,7 +285,6 @@ fn image_pull_with_invalid_image_name_fails() {
     }
 }
 
-#[cfg(unix)]
 #[allow(clippy::needless_pass_by_value)]
 fn invalid_image_host_pull_handler(req: Request<Body>) -> ResponseFuture {
     // verify that path is /images/create and that the "fromImage" query
@@ -334,26 +321,20 @@ fn invalid_image_host_pull_handler(req: Request<Body>) -> ResponseFuture {
     Box::new(future::ok(response))
 }
 
-// This test is super flaky on Windows for some reason. It keeps occassionally
-// failing on Windows with error 10054 which means the server keeps dropping the
-// socket for no reason apparently.
-#[cfg(unix)]
 #[test]
 fn image_pull_with_invalid_image_host_fails() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         POST "/images/create" => invalid_image_host_pull_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -408,7 +389,6 @@ fn image_pull_with_invalid_image_host_fails() {
     }
 }
 
-#[cfg(unix)]
 #[allow(clippy::needless_pass_by_value)]
 fn image_pull_with_invalid_creds_handler(req: Request<Body>) -> ResponseFuture {
     // verify that path is /images/create and that the "fromImage" query
@@ -457,26 +437,20 @@ fn image_pull_with_invalid_creds_handler(req: Request<Body>) -> ResponseFuture {
     Box::new(future::ok(response))
 }
 
-// This test is super flaky on Windows for some reason. It keeps occassionally
-// failing on Windows with error 10054 which means the server keeps dropping the
-// socket for no reason apparently.
-#[cfg(unix)]
 #[test]
 fn image_pull_with_invalid_creds_fails() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         POST "/images/create" => image_pull_with_invalid_creds_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -531,7 +505,6 @@ fn image_pull_with_invalid_creds_fails() {
     }
 }
 
-#[cfg(unix)]
 #[allow(clippy::needless_pass_by_value)]
 fn image_pull_handler(req: Request<Body>) -> ResponseFuture {
     // verify that path is /images/create and that the "fromImage" query
@@ -562,26 +535,20 @@ fn image_pull_handler(req: Request<Body>) -> ResponseFuture {
     Box::new(future::ok(response))
 }
 
-// This test is super flaky on Windows for some reason. It keeps occassionally
-// failing on Windows with error 10054 which means the server keeps dropping the
-// socket for no reason apparently.
-#[cfg(unix)]
 #[test]
 fn image_pull_succeeds() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         POST "/images/create" => image_pull_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -610,7 +577,6 @@ fn image_pull_succeeds() {
     runtime.block_on(task).unwrap();
 }
 
-#[cfg(unix)]
 #[allow(clippy::needless_pass_by_value)]
 fn image_pull_with_creds_handler(req: Request<Body>) -> ResponseFuture {
     // verify that path is /images/create and that the "fromImage" query
@@ -656,26 +622,20 @@ fn image_pull_with_creds_handler(req: Request<Body>) -> ResponseFuture {
     Box::new(future::ok(response))
 }
 
-// This test is super flaky on Windows for some reason. It keeps occassionally
-// failing on Windows with error 10054 which means the server keeps dropping the
-// socket for no reason apparently.
-#[cfg(unix)]
 #[test]
 fn image_pull_with_creds_succeeds() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         POST "/images/create" => image_pull_with_creds_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -727,20 +687,18 @@ fn image_remove_handler(req: Request<Body>) -> ResponseFuture {
 
 #[test]
 fn image_remove_succeeds() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         DELETE format!("/images/{}", IMAGE_NAME) => image_remove_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -840,20 +798,18 @@ fn container_create_handler(req: Request<Body>) -> ResponseFuture {
 
 #[test]
 fn container_create_succeeds() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         POST "/containers/create" => container_create_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -924,20 +880,18 @@ fn container_start_handler(req: Request<Body>) -> ResponseFuture {
 
 #[test]
 fn container_start_succeeds() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         POST "/containers/m1/start" => container_start_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -962,20 +916,18 @@ fn container_stop_handler(req: Request<Body>) -> ResponseFuture {
 
 #[test]
 fn container_stop_succeeds() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         POST "/containers/m1/stop" => container_stop_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1001,20 +953,18 @@ fn container_stop_with_timeout_handler(req: Request<Body>) -> ResponseFuture {
 
 #[test]
 fn container_stop_with_timeout_succeeds() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         POST "/containers/m1/stop" => container_stop_with_timeout_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1039,20 +989,18 @@ fn container_remove_handler(req: Request<Body>) -> ResponseFuture {
 
 #[test]
 fn container_remove_succeeds() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         DELETE "/containers/m1" => container_remove_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1160,20 +1108,18 @@ fn container_list_handler(req: Request<Body>) -> ResponseFuture {
 
 #[test]
 fn container_list_succeeds() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         GET "/containers/json" => container_list_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1243,20 +1189,18 @@ fn container_logs_handler(req: Request<Body>) -> ResponseFuture {
 
 #[test]
 fn container_logs_succeeds() {
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
         GET "/containers/mod1/logs" => container_logs_handler,
     );
 
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1292,9 +1236,9 @@ fn container_logs_succeeds() {
 
 #[test]
 fn image_remove_with_white_space_name_fails() {
-    let port = get_unused_tcp_port();
-    let server = run_tcp_server("127.0.0.1", port, default_network_handler())
-        .map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", default_network_handler());
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1326,9 +1270,9 @@ fn image_remove_with_white_space_name_fails() {
 
 #[test]
 fn create_fails_for_non_docker_type() {
-    let port = get_unused_tcp_port();
-    let server = run_tcp_server("127.0.0.1", port, default_network_handler())
-        .map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", default_network_handler());
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1365,9 +1309,9 @@ fn create_fails_for_non_docker_type() {
 
 #[test]
 fn start_fails_for_empty_id() {
-    let port = get_unused_tcp_port();
-    let server = run_tcp_server("127.0.0.1", port, default_network_handler())
-        .map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", default_network_handler());
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1397,9 +1341,9 @@ fn start_fails_for_empty_id() {
 
 #[test]
 fn start_fails_for_white_space_id() {
-    let port = get_unused_tcp_port();
-    let server = run_tcp_server("127.0.0.1", port, default_network_handler())
-        .map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", default_network_handler());
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1429,9 +1373,9 @@ fn start_fails_for_white_space_id() {
 
 #[test]
 fn stop_fails_for_empty_id() {
-    let port = get_unused_tcp_port();
-    let server = run_tcp_server("127.0.0.1", port, default_network_handler())
-        .map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", default_network_handler());
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1461,9 +1405,9 @@ fn stop_fails_for_empty_id() {
 
 #[test]
 fn stop_fails_for_white_space_id() {
-    let port = get_unused_tcp_port();
-    let server = run_tcp_server("127.0.0.1", port, default_network_handler())
-        .map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", default_network_handler());
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1493,9 +1437,9 @@ fn stop_fails_for_white_space_id() {
 
 #[test]
 fn restart_fails_for_empty_id() {
-    let port = get_unused_tcp_port();
-    let server = run_tcp_server("127.0.0.1", port, default_network_handler())
-        .map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", default_network_handler());
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1525,9 +1469,9 @@ fn restart_fails_for_empty_id() {
 
 #[test]
 fn restart_fails_for_white_space_id() {
-    let port = get_unused_tcp_port();
-    let server = run_tcp_server("127.0.0.1", port, default_network_handler())
-        .map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", default_network_handler());
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1557,9 +1501,9 @@ fn restart_fails_for_white_space_id() {
 
 #[test]
 fn remove_fails_for_empty_id() {
-    let port = get_unused_tcp_port();
-    let server = run_tcp_server("127.0.0.1", port, default_network_handler())
-        .map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", default_network_handler());
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1589,9 +1533,9 @@ fn remove_fails_for_empty_id() {
 
 #[test]
 fn remove_fails_for_white_space_id() {
-    let port = get_unused_tcp_port();
-    let server = run_tcp_server("127.0.0.1", port, default_network_handler())
-        .map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", default_network_handler());
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1621,9 +1565,9 @@ fn remove_fails_for_white_space_id() {
 
 #[test]
 fn get_fails_for_empty_id() {
-    let port = get_unused_tcp_port();
-    let server = run_tcp_server("127.0.0.1", port, default_network_handler())
-        .map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", default_network_handler());
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1653,9 +1597,9 @@ fn get_fails_for_empty_id() {
 
 #[test]
 fn get_fails_for_white_space_id() {
-    let port = get_unused_tcp_port();
-    let server = run_tcp_server("127.0.0.1", port, default_network_handler())
-        .map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", default_network_handler());
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1691,8 +1635,6 @@ fn runtime_init_network_does_not_exist_create() {
     let create_got_called_lock = Arc::new(RwLock::new(false));
     let create_got_called_lock_cloned = create_got_called_lock.clone();
 
-    let port = get_unused_tcp_port();
-
     let network_handler = make_network_handler(
         move || {
             let mut list_got_called_w = list_got_called_lock.write().unwrap();
@@ -1706,8 +1648,8 @@ fn runtime_init_network_does_not_exist_create() {
         },
     );
 
-    let server =
-        run_tcp_server("127.0.0.1", port, network_handler).map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", network_handler);
+    let server = server.map_err(|err| panic!(err));
 
     let settings = make_settings(Some(json!({
         "moby_runtime": {
@@ -1735,8 +1677,6 @@ fn network_ipv6_create() {
     let create_got_called_lock = Arc::new(RwLock::new(false));
     let create_got_called_lock_cloned = create_got_called_lock.clone();
 
-    let port = get_unused_tcp_port();
-
     let network_handler = make_network_handler(
         move || {
             let mut list_got_called_w = list_got_called_lock.write().unwrap();
@@ -1772,8 +1712,8 @@ fn network_ipv6_create() {
         },
     );
 
-    let server =
-        run_tcp_server("127.0.0.1", port, network_handler).map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", network_handler);
+    let server = server.map_err(|err| panic!(err));
 
     let settings = make_settings(Some(json!({
         "moby_runtime": {
@@ -1819,8 +1759,6 @@ fn runtime_init_network_exist_do_not_create() {
     let create_got_called_lock = Arc::new(RwLock::new(false));
     let create_got_called_lock_cloned = create_got_called_lock.clone();
 
-    let port = get_unused_tcp_port();
-
     let network_handler = make_network_handler(
         move || {
             let mut list_got_called_w = list_got_called_lock.write().unwrap();
@@ -1853,8 +1791,8 @@ fn runtime_init_network_exist_do_not_create() {
         },
     );
 
-    let server =
-        run_tcp_server("127.0.0.1", port, network_handler).map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", network_handler);
+    let server = server.map_err(|err| panic!(err));
 
     let settings = make_settings(Some(json!({
         "moby_runtime": {
@@ -1905,8 +1843,6 @@ fn runtime_system_info_succeeds() {
         Box::new(future::ok(response)) as ResponseFuture
     };
 
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
@@ -1914,12 +1850,12 @@ fn runtime_system_info_succeeds() {
     );
 
     //act
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
@@ -1964,8 +1900,6 @@ fn runtime_system_info_none_returns_unkown() {
         Box::new(future::ok(response)) as ResponseFuture
     };
 
-    let port = get_unused_tcp_port();
-
     let dispatch_table = routes!(
         GET "/networks" => default_get_networks_handler(),
         POST "/networks/create" => default_create_network_handler(),
@@ -1973,12 +1907,12 @@ fn runtime_system_info_none_returns_unkown() {
     );
 
     //act
-    let server = run_tcp_server(
+    let (server, port) = run_tcp_server(
         "127.0.0.1",
-        port,
         make_req_dispatcher(dispatch_table, Box::new(not_found_handler)),
-    )
-    .map_err(|err| eprintln!("{}", err));
+    );
+    let server = server.map_err(|err| panic!(err));
+
     let settings = make_settings(Some(json!({
         "moby_runtime": {
             "uri": &format!("http://localhost:{}", port)
diff --git a/edgelet/edgelet-http-workload/tests/dns-san.rs b/edgelet/edgelet-http-workload/tests/dns-san.rs
index 449b56f0c68..99a461b0f08 100755
--- a/edgelet/edgelet-http-workload/tests/dns-san.rs
+++ b/edgelet/edgelet-http-workload/tests/dns-san.rs
@@ -34,7 +34,6 @@ use edgelet_core::{
 use edgelet_hsm::{Crypto, HsmLock};
 use edgelet_http_workload::WorkloadService;
 use edgelet_test_utils::crypto::TestHsm;
-use edgelet_test_utils::get_unused_tcp_port;
 use edgelet_test_utils::module::{
     TestConfig, TestModule, TestProvisioningResult, TestRuntime, TestSettings,
 };
@@ -188,16 +187,25 @@ fn create_workload_service(module_id: &str) -> (WorkloadService, Crypto) {
     )
 }
 
-fn run_echo_server(server_cert: Identity, port: u16) -> impl Future<Item = (), Error = ()> {
-    let addr = format!("127.0.0.1:{}", port).parse().unwrap();
-    let tcp = TcpListener::bind(&addr).unwrap();
+fn run_echo_server(server_cert: Identity) -> (impl Future<Item = (), Error = ()>, u16) {
+    let tcp = TcpListener::bind(
+        &"127.0.0.1:0"
+            .parse()
+            .expect("hard-coded address is a valid SocketAddr"),
+    )
+    .unwrap();
+    let port = tcp
+        .local_addr()
+        .expect("could not get local address of bound TCP listener")
+        .port();
     let tls_acceptor = tokio_tls::TlsAcceptor::from(
         native_tls::TlsAcceptor::builder(server_cert)
             .build()
             .unwrap(),
     );
 
-    tcp.incoming()
+    let server = tcp
+        .incoming()
         .for_each(move |socket| {
             let tls_accept = tls_acceptor
                 .accept(socket)
@@ -215,7 +223,8 @@ fn run_echo_server(server_cert: Identity, port: u16) -> impl Future<Item = (), E
             tokio::spawn(tls_accept);
             Ok(())
         })
-        .map_err(|err| panic!("server error: {:#?}", err))
+        .map_err(|err| panic!("server error: {:#?}", err));
+    (server, port)
 }
 
 fn run_echo_client(
@@ -304,9 +313,8 @@ fn dns_san_server() {
     let (mut service, identity, home_dir, crypto) = init_test(MODULE_ID, GENERATION_ID);
 
     // start up a simple Echo server using this server cert
-    let port = get_unused_tcp_port();
+    let (server, port) = run_echo_server(identity);
     println!("Test server listening on port {}", port);
-    let server = run_echo_server(identity, port);
     let mut runtime = tokio::runtime::Runtime::new().unwrap();
     runtime.spawn(server);
 
diff --git a/edgelet/edgelet-http/src/lib.rs b/edgelet/edgelet-http/src/lib.rs
index a795f9bed95..6cf2a6109ef 100644
--- a/edgelet/edgelet-http/src/lib.rs
+++ b/edgelet/edgelet-http/src/lib.rs
@@ -271,6 +271,15 @@ where
 
         Run(Box::new(main_execution))
     }
+
+    pub fn port(&self) -> Option<u16> {
+        match &self.incoming {
+            Incoming::Tcp(listener) => listener.local_addr().ok().map(|addr| addr.port()),
+            #[cfg(unix)]
+            Incoming::Tls(listener, _, _) => listener.local_addr().ok().map(|addr| addr.port()),
+            Incoming::Unix(_) => None,
+        }
+    }
 }
 
 pub trait HyperExt {
diff --git a/edgelet/edgelet-http/tests/connector.rs b/edgelet/edgelet-http/tests/connector.rs
index c357f8ccc4c..0ca0755ff99 100644
--- a/edgelet/edgelet-http/tests/connector.rs
+++ b/edgelet/edgelet-http/tests/connector.rs
@@ -8,8 +8,7 @@ use std::io;
 use edgelet_http::UrlConnector;
 #[cfg(windows)]
 use edgelet_test_utils::run_pipe_server;
-use edgelet_test_utils::run_uds_server;
-use edgelet_test_utils::{get_unused_tcp_port, run_tcp_server};
+use edgelet_test_utils::{run_tcp_server, run_uds_server};
 use futures::future;
 use futures::prelude::*;
 use hyper::{
@@ -40,9 +39,8 @@ fn hello_handler(_: Request<Body>) -> impl Future<Item = Response<Body>, Error =
 
 #[test]
 fn tcp_get() {
-    let port = get_unused_tcp_port();
-    let server =
-        run_tcp_server("127.0.0.1", port, hello_handler).map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", hello_handler);
+    let server = server.map_err(|err| panic!(err));
 
     let url = format!("http://localhost:{}", port);
     let connector = UrlConnector::new(&Url::parse(&url).unwrap()).unwrap();
@@ -166,9 +164,8 @@ fn post_handler(
 
 #[test]
 fn tcp_post() {
-    let port = get_unused_tcp_port();
-    let server =
-        run_tcp_server("127.0.0.1", port, post_handler).map_err(|err| eprintln!("{}", err));
+    let (server, port) = run_tcp_server("127.0.0.1", post_handler);
+    let server = server.map_err(|err| panic!(err));
 
     let url = format!("http://localhost:{}", port);
     let connector = UrlConnector::new(&Url::parse(&url).unwrap()).unwrap();
diff --git a/edgelet/edgelet-http/tests/tls.rs b/edgelet/edgelet-http/tests/tls.rs
index 67f587dd511..f8c36db5396 100644
--- a/edgelet/edgelet-http/tests/tls.rs
+++ b/edgelet/edgelet-http/tests/tls.rs
@@ -12,7 +12,6 @@ use edgelet_http::route::{Builder, Parameters, RegexRoutesBuilder, Router};
 use edgelet_http::Error as HttpError;
 use edgelet_http::HyperExt;
 use edgelet_http::{Run, Version};
-use edgelet_test_utils::get_unused_tcp_port;
 
 use futures::{future, Future};
 use hyper::server::conn::Http;
@@ -42,9 +41,9 @@ fn tls_functional_test() {
 
     let client = hyper::Client::builder().build::<_, hyper::Body>(https_connector);
 
-    let port = get_unused_tcp_port();
+    let (server, port) = configure_test("https://localhost:0");
+    let server = server.map_err(|err| eprintln!("{}", err));
     let addr = format!("https://localhost:{}", port);
-    let server = configure_test(&addr).map_err(|err| eprintln!("{}", err));
 
     let mut runtime = tokio::runtime::current_thread::Runtime::new().unwrap();
     runtime.spawn(server);
@@ -57,7 +56,7 @@ fn tls_functional_test() {
     assert_eq!(res.status(), 200);
 }
 
-pub fn configure_test(address: &str) -> Run {
+pub fn configure_test(address: &str) -> (Run, u16) {
     // setup the IOTEDGE_HOMEDIR folder where certs can be generated and stored
     let home_dir = TempDir::new("tls_integration_test").unwrap();
     env::set_var(HOMEDIR_KEY, &home_dir.path());
@@ -92,10 +91,11 @@ pub fn configure_test(address: &str) -> Run {
         .finish();
     let router = Router::from(recognizer);
 
-    Http::new()
+    let server = Http::new()
         .bind_url(Url::parse(address).unwrap(), router, Some(&manager))
-        .unwrap()
-        .run()
+        .unwrap();
+    let port = server.port().expect("HTTP server must have port");
+    (server.run(), port)
 }
 
 #[allow(clippy::needless_pass_by_value)]
diff --git a/edgelet/edgelet-test-utils/src/lib.rs b/edgelet/edgelet-test-utils/src/lib.rs
index ed4afc23a31..073d194ebb9 100644
--- a/edgelet/edgelet-test-utils/src/lib.rs
+++ b/edgelet/edgelet-test-utils/src/lib.rs
@@ -9,8 +9,6 @@
     clippy::use_self
 )]
 
-use std::net::TcpListener;
-
 pub mod cert;
 pub mod crypto;
 pub mod identity;
@@ -24,11 +22,3 @@ pub use crate::web::run_uds_server;
 
 #[cfg(windows)]
 pub use crate::web::run_pipe_server;
-
-pub fn get_unused_tcp_port() -> u16 {
-    TcpListener::bind("127.0.0.1:0")
-        .unwrap()
-        .local_addr()
-        .unwrap()
-        .port()
-}
diff --git a/edgelet/edgelet-test-utils/src/web/mod.rs b/edgelet/edgelet-test-utils/src/web/mod.rs
index d79a5f22d1d..fc8934cce4f 100644
--- a/edgelet/edgelet-test-utils/src/web/mod.rs
+++ b/edgelet/edgelet-test-utils/src/web/mod.rs
@@ -29,26 +29,27 @@ use mio_uds_windows::net::UnixListener as StdUnixListener;
 
 pub fn run_tcp_server<F, R>(
     ip: &str,
-    port: u16,
     handler: F,
-) -> impl Future<Item = (), Error = hyper::Error>
+) -> (impl Future<Item = (), Error = hyper::Error>, u16)
 where
     F: 'static + Fn(Request<Body>) -> R + Clone + Send,
     R: 'static + Future<Item = Response<Body>, Error = hyper::Error> + Send,
 {
-    let addr = &format!("{}:{}", ip, port).parse().unwrap();
+    let addr = &format!("{}:0", ip).parse().unwrap();
 
     let serve = Http::new()
         .serve_addr(addr, move || service_fn(handler.clone()))
         .unwrap();
-    serve.for_each(|connecting| {
+    let port = serve.incoming_ref().local_addr().port();
+    let server = serve.for_each(|connecting| {
         connecting
             .then(|connection| {
                 let connection = connection.unwrap();
                 Ok::<_, hyper::Error>(connection)
             })
             .flatten()
-    })
+    });
+    (server, port)
 }
 
 pub fn run_uds_server<F, R>(path: &str, handler: F) -> impl Future<Item = (), Error = io::Error>