tests: Use random ports, allowing test to run in parallel

Author: nickamzol

src/main.rs

@@ -45,7 +45,6 @@ fn init_logger(level: tracing::Level) {
 		.with(
 			tracing_subscriber::fmt::layer()
 				.compact()
-				.with_ansi(true)
 				.with_file(false)
 				.with_line_number(false)
 				.with_target(false),

tests/common/mod.rs

@@ -8,12 +8,7 @@ use testcontainers::runners::AsyncRunner;
 use testcontainers::{ContainerAsync, GenericImage};
 use tokio::io::{AsyncBufReadExt, BufReader, Lines};
 use tokio::process::{Child, ChildStdout, Command};
-use tokio::time::{timeout_at, Instant};
 
-const STARTUP_TIMEOUT: Duration = Duration::from_secs(30);
-const STARTED_MESSAGE: &str = "Started DICOMweb server";
-
-/// Spawns a container running the latest version of Orthanc.
 pub async fn spawn_orthanc() -> anyhow::Result<ContainerAsync<GenericImage>> {
 	GenericImage::new("jodogne/orthanc", "latest")
 		.with_exposed_port(4242.tcp())
@@ -24,17 +19,17 @@ pub async fn spawn_orthanc() -> anyhow::Result<ContainerAsync<GenericImage>> {
 		.context("failed to start Orthanc container")
 }
 
-/// Spawns the DICOM-RST binary with the given config and waits until it is ready.
 pub async fn spawn_dicomrst(config: &str) -> anyhow::Result<ServerProcess> {
 	let mut server = ServerProcess::spawn(config)?;
-	server.wait_until_started().await?;
+	server.http_port = server.wait_until_started().await?;
 	Ok(server)
 }
 
 pub struct ServerProcess {
 	child: Child,
 	stdout: Lines<BufReader<ChildStdout>>,
 	workdir: PathBuf,
+	http_port: u16,
 }
 
 impl ServerProcess {
@@ -46,46 +41,52 @@ impl ServerProcess {
 
 		let mut child = Command::new(env!("CARGO_BIN_EXE_dicom-rst"))
 			.stdout(Stdio::piped())
-			.stderr(Stdio::piped())
+			.stderr(Stdio::null())
+			.env("NO_COLOR", "true") // disables colored ANSI output
 			.current_dir(&workdir)
 			.spawn()
 			.context("failed to spawn DICOM-RST server binary")?;
 
 		let stdout = BufReader::new(child.stdout.take().unwrap()).lines();
-		let mut stderr = BufReader::new(child.stderr.take().unwrap()).lines();
-
-		tokio::spawn(async move {
-			while let Ok(Some(line)) = stderr.next_line().await {
-				eprintln!("[dicom-rst] {line}");
-			}
-		});
 
 		Ok(Self {
 			child,
 			stdout,
 			workdir,
+			http_port: 0,
 		})
 	}
 
-	async fn wait_until_started(&mut self) -> anyhow::Result<()> {
-		let deadline = Instant::now() + STARTUP_TIMEOUT;
-
-		loop {
-			match timeout_at(deadline, self.stdout.next_line()).await {
-				Ok(Ok(Some(line))) => {
-					eprintln!("[dicom-rst] {line}");
-					if line.contains(STARTED_MESSAGE) {
-						return Ok(());
-					}
-				}
-				Ok(Ok(None)) => {
-					let status = self.child.wait().await?;
-					bail!("DICOM-RST exited before becoming ready: {status}");
+	async fn wait_until_started(&mut self) -> anyhow::Result<u16> {
+		tokio::time::timeout(Duration::from_secs(15), async {
+			while let Some(line) = self
+				.stdout
+				.next_line()
+				.await
+				.context("Failed to read DICOM-RST stdout")?
+			{
+				if !line.contains("Started DICOMweb server") {
+					continue;
 				}
-				Ok(Err(e)) => return Err(e).context("failed to read DICOM-RST stdout"),
-				Err(_) => bail!("timed out waiting for `{STARTED_MESSAGE}`"),
+
+				let port = line
+					.split_whitespace()
+					.find_map(|part| part.strip_prefix("server.port="))
+					.ok_or_else(|| {
+						anyhow::Error::msg(
+							"DICOM-RST started, but stdout did not contain server.port=",
+						)
+					})?
+					.parse::<u16>()
+					.context("Failed to parse DICOM-RST server.port as u16")?;
+
+				return Ok(port);
 			}
-		}
+
+			bail!("DICOM-RST exited before becoming ready");
+		})
+		.await
+		.context("Timed out waiting for DICOM-RST to start")?
 	}
 }
 
@@ -96,7 +97,7 @@ impl Drop for ServerProcess {
 	}
 }
 
-pub async fn with_test_deployment(
+pub async fn with_test_environment(
 	config: &str,
 	test: impl AsyncFnOnce(DicomWebClient) -> anyhow::Result<()>,
 ) -> anyhow::Result<()> {
@@ -107,9 +108,12 @@ pub async fn with_test_deployment(
 		.context("failed to get mapped Orthanc DIMSE port")?;
 
 	let config = config.replace("${ORTHANC_PORT}", &orthanc_port.to_string());
-	let _server = spawn_dicomrst(&config).await?;
+	let server = spawn_dicomrst(&config).await?;
 
-	let client = DicomWebClient::with_single_url(&format!("http://localhost:8080/aets/ORTHANC"));
+	let client = DicomWebClient::with_single_url(&format!(
+		"http://localhost:{}/aets/ORTHANC",
+		server.http_port
+	));
 	test(client).await?;
 
 	Ok(())

tests/stow.rs

@@ -11,12 +11,19 @@ use std::time::{Duration, Instant};
 #[tokio::test]
 async fn can_upload_study_instances() -> anyhow::Result<()> {
 	let config = "
+        server:
+          http:
+            port: 0
+          dimse:
+            - aet: DICOM-RST
+              interface: 0.0.0.0
+              port: 0
         aets:
           - aet: ORTHANC
             host: 127.0.0.1
             port: ${ORTHANC_PORT}
             backend: DIMSE
-	";
+    ";
 
 	let instances = [
 		"pydicom/liver.dcm",
@@ -26,7 +33,7 @@ async fn can_upload_study_instances() -> anyhow::Result<()> {
 	.map(|path| open_file(dicom_test_files::path(path).unwrap()).unwrap());
 	let instances = futures::stream::iter(instances);
 
-	with_test_deployment(&config, async |client| {
+	with_test_environment(config, async |client| {
 		let response = client
 			.store_instances()
 			.with_instances(instances.clone())
@@ -67,6 +74,13 @@ async fn can_upload_study_instances() -> anyhow::Result<()> {
 #[tokio::test]
 async fn does_not_leak_semaphore_permits_if_association_is_rejected() -> anyhow::Result<()> {
 	let config = "
+        server:
+          http:
+            port: 0
+          dimse:
+            - aet: DICOM-RST
+              interface: 0.0.0.0
+              port: 0
         aets:
           - aet: ORTHANC
             host: 127.0.0.1
@@ -88,7 +102,7 @@ async fn does_not_leak_semaphore_permits_if_association_is_rejected() -> anyhow:
 	};
 	let instances = [create_instance(), create_instance(), create_instance()];
 
-	with_test_deployment(config, async |client| {
+	with_test_environment(config, async |client| {
 		let start = Instant::now();
 		let response = client
 			.store_instances()
@@ -124,15 +138,20 @@ async fn returns_413_if_max_upload_size_is_exceeded() -> anyhow::Result<()> {
 	let config = "
         server:
           http:
+            port: 0
             max-upload-size: 1
+          dimse:
+            - aet: DICOM-RST
+              interface: 0.0.0.0
+              port: 0
         aets:
           - aet: ORTHANC
             host: 127.0.0.1
             port: ${ORTHANC_PORT}
             backend: DIMSE
 	";
 
-	with_test_deployment(config, async |client| {
+	with_test_environment(config, async |client| {
 		let instance = open_file(dicom_test_files::path("pydicom/CT_small.dcm").unwrap()).unwrap();
 		let result = client
 			.store_instances()