Use different directories for cluster marker tests

crates/admin/Cargo.toml

@@ -52,7 +52,7 @@ tracing = { workspace = true }
 
 [dev-dependencies]
 restate-schema = { workspace = true, features = ["test-util"] }
-restate-schema-api = { workspace = true, features = ["mocks"] }
+restate-schema-api = { workspace = true, features = ["test-util"] }
 restate-test-util = { workspace = true }
 
 tempfile = { workspace = true }

crates/ingress-dispatcher/Cargo.toml

@@ -9,7 +9,7 @@ publish = false
 
 [features]
 default = []
-mocks = ["dep:restate-test-util"]
+test-util = ["dep:restate-test-util"]
 
 [dependencies]
 restate-bifrost = { workspace = true }

crates/ingress-dispatcher/src/lib.rs

@@ -276,8 +276,8 @@ impl IngressDispatcherRequest {
     }
 }
 
-#[cfg(feature = "mocks")]
-pub mod mocks {
+#[cfg(feature = "test-util")]
+pub mod test_util {
     use super::*;
 
     use crate::error::IngressDispatchError;

crates/ingress-http/Cargo.toml

@@ -65,10 +65,10 @@ humantime = { workspace = true }
 
 [dev-dependencies]
 restate-core = { workspace = true, features = ["test-util"] }
-restate-ingress-dispatcher = { workspace = true, features = ["mocks"] }
+restate-ingress-dispatcher = { workspace = true, features = ["test-util"] }
 restate-test-util = { workspace = true }
 restate-types = { workspace = true, features = ["test-util"] }
-restate-schema-api = { workspace = true, features = ["mocks"]}
+restate-schema-api = { workspace = true, features = ["test-util"]}
 
 hyper = { version = "1.0", features = ["full"] }
 hyper-util = { version = "0.1", features = ["full"] }

crates/ingress-http/src/handler/tests.rs

@@ -24,7 +24,7 @@ use http::StatusCode;
 use http::{Method, Request, Response};
 use http_body_util::{BodyExt, Empty, Full};
 use restate_core::TestCoreEnv;
-use restate_ingress_dispatcher::mocks::MockDispatcher;
+use restate_ingress_dispatcher::test_util::MockDispatcher;
 use restate_ingress_dispatcher::IngressDispatcherRequest;
 use restate_schema_api::invocation_target::{
     InputContentType, InputRules, InputValidationRule, InvocationTargetMetadata,

crates/ingress-http/src/lib.rs

@@ -58,11 +58,11 @@ mod mocks {
     use super::*;
 
     use anyhow::Error;
-    use restate_schema_api::invocation_target::mocks::MockInvocationTargetResolver;
+    use restate_schema_api::invocation_target::test_util::MockInvocationTargetResolver;
     use restate_schema_api::invocation_target::{
         InvocationTargetMetadata, InvocationTargetResolver, DEFAULT_IDEMPOTENCY_RETENTION,
     };
-    use restate_schema_api::service::mocks::MockServiceMetadataResolver;
+    use restate_schema_api::service::test_util::MockServiceMetadataResolver;
     use restate_schema_api::service::{HandlerMetadata, ServiceMetadata, ServiceMetadataResolver};
     use restate_types::identifiers::DeploymentId;
     use restate_types::ingress::InvocationResponse;

crates/ingress-http/src/server.rs

@@ -246,7 +246,7 @@ mod tests {
     use hyper_util::client::legacy::Client;
     use hyper_util::rt::TokioExecutor;
     use restate_core::{TaskCenter, TaskKind, TestCoreEnv};
-    use restate_ingress_dispatcher::mocks::MockDispatcher;
+    use restate_ingress_dispatcher::test_util::MockDispatcher;
     use restate_ingress_dispatcher::{IngressDispatcherRequest, IngressInvocationResponse};
     use restate_test_util::assert_eq;
     use restate_types::identifiers::InvocationId;

crates/ingress-kafka/Cargo.toml

@@ -33,9 +33,9 @@ tracing = { workspace = true }
 tracing-opentelemetry = { workspace = true }
 
 [dev-dependencies]
-restate-ingress-dispatcher = { workspace = true, features = ["mocks"] }
+restate-ingress-dispatcher = { workspace = true, features = ["test-util"] }
 restate-schema = { workspace = true }
-restate-schema-api = { workspace = true, features = ["mocks"] }
+restate-schema-api = { workspace = true, features = ["test-util"] }
 restate-test-util = { workspace = true }
 restate-types = { workspace = true, features = ["test-util"] }
 

crates/invoker-api/Cargo.toml

@@ -9,14 +9,13 @@ publish = false
 
 [features]
 default = []
-mocks = []
+test-util = ["restate-types/test-util"]
 serde = ["dep:serde"]
 
 [dependencies]
 restate-errors = { workspace = true }
 restate-types = { workspace = true }
 
-
 anyhow = { workspace = true }
 bytes = { workspace = true }
 bytestring = { workspace = true }

crates/invoker-api/src/entry_enricher.rs

@@ -22,8 +22,8 @@ pub trait EntryEnricher {
     ) -> Result<EnrichedRawEntry, InvocationError>;
 }
 
-#[cfg(any(test, feature = "mocks"))]
-pub mod mocks {
+#[cfg(any(test, feature = "test-util"))]
+pub mod test_util {
     use super::*;
 
     use restate_types::identifiers::{InvocationId, InvocationUuid};

crates/invoker-api/src/lib.rs

@@ -22,8 +22,8 @@ pub use journal_reader::{JournalMetadata, JournalReader};
 pub use state_reader::{EagerState, StateReader};
 pub use status_handle::{InvocationErrorReport, InvocationStatusReport, StatusHandle};
 
-#[cfg(any(test, feature = "mocks"))]
-pub mod mocks {
+#[cfg(any(test, feature = "test-util"))]
+pub mod test_util {
     use super::*;
     use bytes::Bytes;
     use restate_types::identifiers::{InvocationId, ServiceId};

crates/invoker-api/src/status_handle.rs

@@ -124,8 +124,8 @@ pub trait StatusHandle {
     ) -> impl Future<Output = Self::Iterator> + Send;
 }
 
-#[cfg(any(test, feature = "mocks"))]
-pub mod mocks {
+#[cfg(any(test, feature = "test-util"))]
+pub mod test_util {
     use super::*;
 
     #[derive(Debug, Clone, Default)]

crates/invoker-impl/Cargo.toml

@@ -47,8 +47,8 @@ tracing-opentelemetry = { workspace = true }
 
 [dev-dependencies]
 restate-core = { workspace = true, features = ["test-util"] }
-restate-invoker-api = { workspace = true, features = ["mocks"] }
-restate-schema-api = { workspace = true, features = ["mocks"] }
+restate-invoker-api = { workspace = true, features = ["test-util"] }
+restate-schema-api = { workspace = true, features = ["test-util"] }
 restate-service-protocol = { workspace = true, features = ["codec"] }
 restate-test-util = { workspace = true }
 restate-types = { workspace = true }

crates/invoker-impl/src/invocation_task/service_protocol_runner.rs

@@ -40,8 +40,7 @@ use restate_types::journal::EntryType;
 use restate_types::service_protocol::ServiceProtocolVersion;
 use std::collections::HashSet;
 use std::future::poll_fn;
-use tracing::log::warn;
-use tracing::{debug, info, trace, Span};
+use tracing::{debug, info, trace, warn, Span};
 use tracing_opentelemetry::OpenTelemetrySpanExt;
 
 /// Runs the interaction between the server and the service endpoint.

crates/invoker-impl/src/lib.rs

@@ -1022,7 +1022,7 @@ mod tests {
     use bytes::Bytes;
     use restate_core::TaskKind;
     use restate_core::TestCoreEnv;
-    use restate_invoker_api::mocks::EmptyStorageReader;
+    use restate_invoker_api::test_util::EmptyStorageReader;
     use restate_types::arc_util::Constant;
     use restate_types::config::InvokerOptionsBuilder;
     use tempfile::tempdir;
@@ -1031,7 +1031,7 @@ mod tests {
     use tokio_util::sync::CancellationToken;
 
     use restate_invoker_api::{entry_enricher, ServiceHandle};
-    use restate_schema_api::deployment::mocks::MockDeploymentMetadataRegistry;
+    use restate_schema_api::deployment::test_util::MockDeploymentMetadataRegistry;
     use restate_test_util::{check, let_assert};
     use restate_types::identifiers::{LeaderEpoch, PartitionId};
     use restate_types::journal::enriched::EnrichedEntryHeader;
@@ -1162,7 +1162,7 @@ mod tests {
                 restate_service_client::AssumeRoleCacheMode::None,
             )
             .unwrap(),
-            entry_enricher::mocks::MockEntryEnricher,
+            entry_enricher::test_util::MockEntryEnricher,
         );
 
         let mut handle = service.handle();

crates/node/src/cluster_marker.rs

@@ -235,9 +235,8 @@ mod tests {
     use semver::Version;
     use std::fs;
     use std::fs::OpenOptions;
-    use std::io::Write;
     use std::path::Path;
-    use tempfile::{tempdir, NamedTempFile};
+    use tempfile::tempdir;
 
     fn read_cluster_marker(path: impl AsRef<Path>) -> anyhow::Result<ClusterMarker> {
         let bytes = fs::read(path)?;
@@ -248,11 +247,8 @@ mod tests {
         cluster_marker: &ClusterMarker,
         path: impl AsRef<Path>,
     ) -> anyhow::Result<()> {
-        let mut file = OpenOptions::new().create(true).write(true).open(path)?;
+        let file = OpenOptions::new().create(true).write(true).open(path)?;
         serde_json::to_writer(&file, cluster_marker)?;
-        file.flush()?;
-        file.sync_all()?;
-
         Ok(())
     }
 
@@ -263,10 +259,8 @@ mod tests {
 
     #[test]
     fn cluster_marker_is_created() {
-        let file = tempdir()
-            .unwrap()
-            .into_path()
-            .join(CLUSTER_MARKER_FILE_NAME);
+        let dir = tempdir().unwrap();
+        let file = dir.path().join(CLUSTER_MARKER_FILE_NAME);
         let current_version = Version::new(2, 2, 3);
 
         validate_and_update_cluster_marker_inner(
@@ -296,7 +290,8 @@ mod tests {
 
     #[test]
     fn cluster_marker_is_updated() -> anyhow::Result<()> {
-        let mut file = NamedTempFile::new().unwrap();
+        let dir = tempdir().unwrap();
+        let file = dir.path().join(CLUSTER_MARKER_FILE_NAME);
         let previous_version = Version::new(1, 1, 6);
         let current_version = Version::new(2, 2, 3);
 
@@ -308,20 +303,19 @@ mod tests {
                     .min_forward_compatible_version
                     .clone(),
             ),
-            file.path(),
+            &file,
         )
         .unwrap();
-        file.flush()?;
 
         validate_and_update_cluster_marker_inner(
             CLUSTER_NAME,
             current_version.clone(),
-            file.path(),
+            &file,
             &TESTING_COMPATIBILITY_INFORMATION,
         )
         .unwrap();
 
-        let cluster_marker = read_cluster_marker(file.path()).unwrap();
+        let cluster_marker = read_cluster_marker(file).unwrap();
 
         assert_eq!(
             cluster_marker,
@@ -341,7 +335,8 @@ mod tests {
 
     #[test]
     fn max_version_is_maintained() -> anyhow::Result<()> {
-        let mut file = NamedTempFile::new().unwrap();
+        let dir = tempdir().unwrap();
+        let file = dir.path().join(CLUSTER_MARKER_FILE_NAME);
         let max_version = Version::new(2, 2, 6);
         let current_version = Version::new(2, 1, 3);
 
@@ -353,20 +348,19 @@ mod tests {
                     .min_forward_compatible_version
                     .clone(),
             ),
-            file.path(),
+            &file,
         )
         .unwrap();
-        file.flush()?;
 
         validate_and_update_cluster_marker_inner(
             CLUSTER_NAME,
             current_version.clone(),
-            file.path(),
+            &file,
             &TESTING_COMPATIBILITY_INFORMATION,
         )
         .unwrap();
 
-        let cluster_marker = read_cluster_marker(file.path()).unwrap();
+        let cluster_marker = read_cluster_marker(file).unwrap();
 
         assert_eq!(
             cluster_marker,
@@ -386,7 +380,8 @@ mod tests {
 
     #[test]
     fn incompatible_cluster_name() -> anyhow::Result<()> {
-        let mut file = NamedTempFile::new().unwrap();
+        let dir = tempdir().unwrap();
+        let file = dir.path().join(CLUSTER_MARKER_FILE_NAME);
         let max_version = Version::new(2, 2, 6);
         let current_version = Version::new(2, 1, 3);
 
@@ -398,15 +393,14 @@ mod tests {
                     .min_forward_compatible_version
                     .clone(),
             ),
-            file.path(),
+            &file,
         )
         .unwrap();
-        file.flush()?;
 
         let result = validate_and_update_cluster_marker_inner(
             CLUSTER_NAME,
             current_version.clone(),
-            file.path(),
+            &file,
             &TESTING_COMPATIBILITY_INFORMATION,
         );
         assert!(matches!(
@@ -418,7 +412,8 @@ mod tests {
 
     #[test]
     fn forward_incompatible_version() -> anyhow::Result<()> {
-        let mut file = NamedTempFile::new().unwrap();
+        let dir = tempdir().unwrap();
+        let file = dir.path().join(CLUSTER_MARKER_FILE_NAME);
         let max_version = Version::new(2, 2, 6);
         let this_version = Version::new(1, 0, 3);
 
@@ -428,15 +423,14 @@ mod tests {
                 max_version.clone(),
                 Version::new(2, 0, 0),
             ),
-            file.path(),
+            &file,
         )
         .unwrap();
-        file.flush()?;
 
         let result = validate_and_update_cluster_marker_inner(
             CLUSTER_NAME,
             this_version.clone(),
-            file.path(),
+            &file,
             &COMPATIBILITY_INFORMATION,
         );
         assert!(matches!(
@@ -448,7 +442,8 @@ mod tests {
 
     #[test]
     fn backward_incompatible_version() -> anyhow::Result<()> {
-        let mut file = NamedTempFile::new().unwrap();
+        let dir = tempdir().unwrap();
+        let file = dir.path().join(CLUSTER_MARKER_FILE_NAME);
         let max_version = Version::new(0, 9, 2);
         let this_version = Version::new(2, 1, 1);
         write_cluster_marker(
@@ -457,15 +452,14 @@ mod tests {
                 max_version.clone(),
                 Version::new(0, 9, 0),
             ),
-            file.path(),
+            &file,
         )
         .unwrap();
-        file.flush()?;
 
         let result = validate_and_update_cluster_marker_inner(
             CLUSTER_NAME,
             this_version.clone(),
-            file.path(),
+            &file,
             &COMPATIBILITY_INFORMATION,
         );
         assert!(matches!(
@@ -478,7 +472,8 @@ mod tests {
 
     #[test]
     fn compatible_version() -> anyhow::Result<()> {
-        let mut file = NamedTempFile::new().unwrap();
+        let dir = tempdir().unwrap();
+        let file = dir.path().join(CLUSTER_MARKER_FILE_NAME);
         let max_version = Version::new(2, 0, 2);
         let this_version = Version::new(2, 3, 1);
         write_cluster_marker(
@@ -489,15 +484,14 @@ mod tests {
                     .min_forward_compatible_version
                     .clone(),
             ),
-            file.path(),
+            &file,
         )
         .unwrap();
-        file.flush()?;
 
         let result = validate_and_update_cluster_marker_inner(
             CLUSTER_NAME,
             this_version.clone(),
-            file.path(),
+            &file,
             &TESTING_COMPATIBILITY_INFORMATION,
         );
         assert!(result.is_ok());