From beee1886f9124aeed6c7e5fc004803e63bd6459a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Raphael=20H=C3=B6ser?= Date: Tue, 22 Jul 2025 23:14:41 +0200 Subject: [PATCH 1/3] feat(preconditions): add support for isEventQLTrue preconditions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Raphael Höser --- README.md | 17 +++++++++++++++++ src/client/precondition.rs | 6 ++++++ tests/write_events.rs | 20 ++++++++++++++++++++ 3 files changed, 43 insertions(+) diff --git a/README.md b/README.md index 05c7207..e6bd59a 100644 --- a/README.md +++ b/README.md @@ -114,6 +114,23 @@ match result { *Note that according to the CloudEvents standard, event IDs must be of type string.* +#### Using the `IsEventQLTrue` precondition + +If you want to write events depending on an EventQL query, use the `IsEventQLTrue` precondition to create a precondition and pass it in a vector as the second argument: + +```rust +let result = client.write_events( + vec![event.clone()], + vec![Precondition::IsEventQLTrue { + query: "FROM e IN events WHERE e.type == 'io.eventsourcingdb.library.book-borrowed' PROJECT INTO COUNT() < 10".to_string(), + }], +).await; +match result { + Ok(written_events) => // ... + Err(err) => // ... +} +``` + ### Reading Events To read all events of a subject, call the `read_events` function with the subject and an options object. Set the `recursive` option to `false`. This ensures that only events of the given subject are returned, not events of nested subjects. diff --git a/src/client/precondition.rs b/src/client/precondition.rs index fbb47d0..f2328b6 100644 --- a/src/client/precondition.rs +++ b/src/client/precondition.rs @@ -19,4 +19,10 @@ pub enum Precondition { #[serde(rename = "eventId")] event_id: String, }, + /// Check if an EventQL query returns true + #[serde(rename = "isEventQlTrue")] + IsEventQLTrue { + /// The EventQL query to check + query: String, + }, } diff --git a/tests/write_events.rs b/tests/write_events.rs index b5d74da..7b6f5f1 100644 --- a/tests/write_events.rs +++ b/tests/write_events.rs @@ -212,6 +212,26 @@ async fn write_events_with_is_subject_on_event_id_condition_on_empty_subject() { assert!(result.is_err(), "Expected an error, but got: {:?}", result); } +#[tokio::test] +async fn write_events_with_is_eventql_true_condition() { + let container = Container::start_default().await.unwrap(); + let client = container.get_client().await.unwrap(); + + let event_candidates = vec![ + create_test_eventcandidate("/test/42", json!({"value": 1})), + create_test_eventcandidate("/test/42", json!({"value": 1})), + ]; + let result = client + .write_events( + event_candidates.clone(), + vec![Precondition::IsEventQLTrue { + query: "FROM e IN events PROJECT INTO COUNT() == 0".to_string(), + }], + ) + .await; + assert!(result.is_err(), "Expected an error, but got: {:?}", result); +} + #[tokio::test] async fn write_events_with_is_subject_on_event_id_condition_on_non_empty_subject_correct_id() { let container = Container::start_default().await.unwrap(); From c944087d12e1da8ab999bed9611871b6ad706666 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Raphael=20H=C3=B6ser?= Date: Tue, 22 Jul 2025 23:20:29 +0200 Subject: [PATCH 2/3] fix(tests): fix inverted test condition MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Raphael Höser --- tests/write_events.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/write_events.rs b/tests/write_events.rs index 7b6f5f1..47e8be2 100644 --- a/tests/write_events.rs +++ b/tests/write_events.rs @@ -229,7 +229,7 @@ async fn write_events_with_is_eventql_true_condition() { }], ) .await; - assert!(result.is_err(), "Expected an error, but got: {:?}", result); + assert!(result.is_ok(), "Expected an ok, but got: {:?}", result); } #[tokio::test] From 473fd0d3bd29c91b5ab623b7a0833cfe31c25981 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Raphael=20H=C3=B6ser?= Date: Tue, 22 Jul 2025 23:43:07 +0200 Subject: [PATCH 3/3] chore(tests): switch to preview container image for tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Raphael Höser --- tests/essentials.rs | 16 ++++---- tests/metadata_and_discovery.rs | 23 ++++++------ tests/observe_events.rs | 7 ++-- tests/read_events.rs | 32 ++++++++-------- tests/run_eventql_query.rs | 7 ++-- tests/utils/mod.rs | 10 ++++- tests/write_events.rs | 66 ++++++++++++++++----------------- 7 files changed, 84 insertions(+), 77 deletions(-) diff --git a/tests/essentials.rs b/tests/essentials.rs index 1c91762..615cbcd 100644 --- a/tests/essentials.rs +++ b/tests/essentials.rs @@ -1,8 +1,10 @@ -use eventsourcingdb::{Client, container::Container}; +mod utils; +use eventsourcingdb::Client; +use utils::create_test_container; #[tokio::test] async fn ping() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); client.ping().await.expect("Failed to ping"); } @@ -11,12 +13,12 @@ async fn ping() { async fn ping_unavailable_server_errors() { let client = Client::new("http://localhost:12345".parse().unwrap(), "secrettoken"); let result = client.ping().await; - assert!(result.is_err(), "Expected an error, but got: {:?}", result); + assert!(result.is_err(), "Expected an error, but got: {result:?}"); } #[tokio::test] async fn verify_api_token() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); client .verify_api_token() @@ -28,14 +30,14 @@ async fn verify_api_token() { async fn verify_api_token_unavailable_server_errors() { let client = Client::new("http://localhost:12345".parse().unwrap(), "secrettoken"); let result = client.verify_api_token().await; - assert!(result.is_err(), "Expected an error, but got: {:?}", result); + assert!(result.is_err(), "Expected an error, but got: {result:?}"); } #[tokio::test] async fn verify_api_token_invalid_token_errors() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let invalid_client = Client::new(client.get_base_url().clone(), "invalid_token"); let result = invalid_client.verify_api_token().await; - assert!(result.is_err(), "Expected an error, but got: {:?}", result); + assert!(result.is_err(), "Expected an error, but got: {result:?}"); } diff --git a/tests/metadata_and_discovery.rs b/tests/metadata_and_discovery.rs index a3abc56..0abba51 100644 --- a/tests/metadata_and_discovery.rs +++ b/tests/metadata_and_discovery.rs @@ -1,10 +1,11 @@ -use eventsourcingdb::container::Container; +mod utils; use futures::StreamExt; use serde_json::json; +use utils::create_test_container; #[tokio::test] async fn register_event_schema() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); client .register_event_schema( @@ -28,7 +29,7 @@ async fn register_event_schema() { #[tokio::test] async fn register_invalid_event_schema() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let res = client .register_event_schema( @@ -38,12 +39,12 @@ async fn register_invalid_event_schema() { }), ) .await; - assert!(res.is_err(), "Expected an error, but got: {:?}", res); + assert!(res.is_err(), "Expected an error, but got: {res:?}"); } #[tokio::test] async fn list_all_subjects() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let res = client.list_subjects(None).await; match res { @@ -51,11 +52,10 @@ async fn list_all_subjects() { let subjects = subjects.collect::>().await; assert!( subjects.is_empty(), - "Expected no subjects, but got: {:?}", - subjects + "Expected no subjects, but got: {subjects:?}" ); } - Err(err) => panic!("Failed to list subjects: {:?}", err), + Err(err) => panic!("Failed to list subjects: {err:?}"), } } @@ -65,7 +65,7 @@ async fn list_all_subjects() { #[tokio::test] async fn list_all_event_types() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let test_event_type = "io.eventsourcingdb.test"; let schema = json!({ @@ -90,8 +90,7 @@ async fn list_all_event_types() { let mut event_types = event_types.collect::>().await; assert!( event_types.len() == 1, - "Expected one event types, but got: {:?}", - event_types + "Expected one event types, but got: {event_types:?}" ); assert!(event_types[0].is_ok(), "Expected event type to be ok"); let response_event_type = event_types.pop().unwrap().unwrap(); @@ -113,7 +112,7 @@ async fn list_all_event_types() { response_event_type.is_phantom ); } - Err(err) => panic!("Failed to list event types: {:?}", err), + Err(err) => panic!("Failed to list event types: {err:?}"), } } diff --git a/tests/observe_events.rs b/tests/observe_events.rs index 87d5ae1..4dd1a8e 100644 --- a/tests/observe_events.rs +++ b/tests/observe_events.rs @@ -1,13 +1,12 @@ mod utils; - -use eventsourcingdb::container::Container; use futures::stream::StreamExt; use serde_json::json; +use utils::create_test_container; use utils::create_test_eventcandidate; #[tokio::test] async fn observe_existing_events() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidate = create_test_eventcandidate("/test", json!({"value": 1})); let written = client @@ -30,7 +29,7 @@ async fn observe_existing_events() { #[tokio::test] async fn keep_observing_events() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let mut events_stream = client diff --git a/tests/read_events.rs b/tests/read_events.rs index 0f773ba..8d07cc7 100644 --- a/tests/read_events.rs +++ b/tests/read_events.rs @@ -1,34 +1,32 @@ mod utils; -use eventsourcingdb::{ - container::Container, - request_options::{ - Ordering, ReadEventMissingStrategy, ReadEventsOptions, ReadFromLatestEventOptions, - }, +use eventsourcingdb::request_options::{ + Ordering, ReadEventMissingStrategy, ReadEventsOptions, ReadFromLatestEventOptions, }; use futures::TryStreamExt; use serde_json::json; +use utils::create_test_container; use utils::{ assert_event_match_eventcandidate, create_numbered_eventcandidates, create_test_eventcandidate, }; #[tokio::test] async fn make_read_call() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let events_stream = client .read_events("/", None) .await .expect("Failed to read events"); let events: Result, _> = events_stream.try_collect().await; - assert!(events.is_ok(), "Failed to write events: {:?}", events); + assert!(events.is_ok(), "Failed to write events: {events:?}"); let events = events.expect("Failed to read events"); assert_eq!(events.len(), 0); } #[tokio::test] async fn make_read_call_with_event() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidate = create_test_eventcandidate("/test", json!({"value": 1})); let written = client @@ -50,7 +48,7 @@ async fn make_read_call_with_event() { #[tokio::test] async fn make_read_call_with_multiple_events() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidates = create_numbered_eventcandidates(10); let written = client @@ -72,7 +70,7 @@ async fn make_read_call_with_multiple_events() { #[tokio::test] async fn read_from_exact_topic() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidate = create_test_eventcandidate("/test", json!({"value": 1})); client @@ -102,7 +100,7 @@ async fn read_from_exact_topic() { #[tokio::test] async fn read_recursive() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidate_parent = create_test_eventcandidate("/test", json!({"value": 1})); let event_candidate_child = create_test_eventcandidate("/test/sub", json!({"value": 2})); @@ -137,7 +135,7 @@ async fn read_recursive() { #[tokio::test] async fn read_not_recursive() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidate_parent = create_test_eventcandidate("/test", json!({"value": 1})); let event_candidate_child = create_test_eventcandidate("/test/sub", json!({"value": 2})); @@ -172,7 +170,7 @@ async fn read_not_recursive() { #[tokio::test] async fn read_chronological() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidates = create_numbered_eventcandidates(10); let written = client @@ -200,7 +198,7 @@ async fn read_chronological() { #[tokio::test] async fn read_antichronological() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidates = create_numbered_eventcandidates(10); let written = client @@ -230,7 +228,7 @@ async fn read_antichronological() { #[tokio::test] async fn read_everything_from_missing_latest_event() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidates = create_numbered_eventcandidates(10); let written = client @@ -262,7 +260,7 @@ async fn read_everything_from_missing_latest_event() { #[tokio::test] async fn read_nothing_from_missing_latest_event() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidates = create_numbered_eventcandidates(10); client @@ -294,7 +292,7 @@ async fn read_nothing_from_missing_latest_event() { #[tokio::test] async fn read_from_latest_event() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidates = create_numbered_eventcandidates(10); client diff --git a/tests/run_eventql_query.rs b/tests/run_eventql_query.rs index 1022711..9edb0e4 100644 --- a/tests/run_eventql_query.rs +++ b/tests/run_eventql_query.rs @@ -1,16 +1,17 @@ -use eventsourcingdb::container::Container; +mod utils; use futures::stream::TryStreamExt; +use utils::create_test_container; #[tokio::test] async fn run_empty_query() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let rows = client .run_eventql_query("FROM e IN events ORDER BY e.time DESC TOP 100 PROJECT INTO e") .await .expect("Unable to run query"); let rows: Result, _> = rows.try_collect().await; - assert!(rows.is_ok(), "Failed to run query: {:?}", rows); + assert!(rows.is_ok(), "Failed to run query: {rows:?}"); let rows = rows.expect("Failed to read rows"); assert_eq!(rows.len(), 0); } diff --git a/tests/utils/mod.rs b/tests/utils/mod.rs index cf2fd3d..26ef27d 100644 --- a/tests/utils/mod.rs +++ b/tests/utils/mod.rs @@ -1,7 +1,15 @@ use chrono::{TimeDelta, Utc}; -use eventsourcingdb::{Event, EventCandidate}; +use eventsourcingdb::{Event, EventCandidate, container::Container}; use serde_json::{Value, json}; +pub async fn create_test_container() -> Container { + Container::builder() + .with_image_tag("preview") + .start() + .await + .expect("Failed to start test container") +} + pub fn create_test_eventcandidate( subject: impl ToString, data: impl Into, diff --git a/tests/write_events.rs b/tests/write_events.rs index 47e8be2..9b386ec 100644 --- a/tests/write_events.rs +++ b/tests/write_events.rs @@ -1,19 +1,19 @@ mod utils; -use eventsourcingdb::{EventCandidate, Precondition, TraceInfo, container::Container}; +use eventsourcingdb::{EventCandidate, Precondition, TraceInfo}; use serde_json::json; use utils::{ assert_event_match_eventcandidate, assert_events_match_eventcandidates, - create_numbered_eventcandidates, create_test_eventcandidate, + create_numbered_eventcandidates, create_test_container, create_test_eventcandidate, }; #[tokio::test] async fn write_single_event() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event = create_test_eventcandidate("/test", json!({"value": 1})); let result = client.write_events(vec![event.clone()], vec![]).await; - assert!(result.is_ok(), "Failed to write events: {:?}", result); + assert!(result.is_ok(), "Failed to write events: {result:?}"); let mut response = result.unwrap(); assert_eq!(response.len(), 1, "Expected one event in the response"); let response_event = response.pop().unwrap(); @@ -23,13 +23,13 @@ async fn write_single_event() { #[tokio::test] async fn write_multiple_events() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidates = create_numbered_eventcandidates(10); let result = client.write_events(event_candidates.clone(), vec![]).await; - assert!(result.is_ok(), "Failed to write events: {:?}", result); + assert!(result.is_ok(), "Failed to write events: {result:?}"); let response = result.unwrap(); assert_events_match_eventcandidates(&response, &event_candidates); @@ -37,7 +37,7 @@ async fn write_multiple_events() { #[tokio::test] async fn write_event_with_is_pristine_condition_on_empty_subject() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidate = create_test_eventcandidate("/test/42", json!({"value": 1})); @@ -49,7 +49,7 @@ async fn write_event_with_is_pristine_condition_on_empty_subject() { }], ) .await; - assert!(result.is_ok(), "Failed to write events: {:?}", result); + assert!(result.is_ok(), "Failed to write events: {result:?}"); let mut response = result.unwrap(); assert_eq!(response.len(), 1, "Expected one event in the response"); let response_event = response.pop().unwrap(); @@ -59,7 +59,7 @@ async fn write_event_with_is_pristine_condition_on_empty_subject() { #[tokio::test] async fn write_event_with_is_pristine_condition_on_non_empty_subject() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidate = create_test_eventcandidate("/test", json!({"value": 1})); @@ -75,12 +75,12 @@ async fn write_event_with_is_pristine_condition_on_non_empty_subject() { }], ) .await; - assert!(result.is_err(), "Expected an error, but got: {:?}", result); + assert!(result.is_err(), "Expected an error, but got: {result:?}"); } #[tokio::test] async fn write_events_with_is_pristine_condition_on_empty_subject() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidates = vec![ @@ -95,14 +95,14 @@ async fn write_events_with_is_pristine_condition_on_empty_subject() { }], ) .await; - assert!(result.is_ok(), "Failed to write events: {:?}", result); + assert!(result.is_ok(), "Failed to write events: {result:?}"); let response = result.unwrap(); assert_events_match_eventcandidates(&response, &event_candidates); } #[tokio::test] async fn write_events_with_is_pristine_condition_on_non_empty_subject() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let fill_event_candidate = create_test_eventcandidate("/test", json!({"value": 1})); @@ -122,12 +122,12 @@ async fn write_events_with_is_pristine_condition_on_non_empty_subject() { }], ) .await; - assert!(result.is_err(), "Expected an error, but got: {:?}", result); + assert!(result.is_err(), "Expected an error, but got: {result:?}"); } #[tokio::test] async fn write_event_with_is_subject_on_event_id_condition_on_empty_subject() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidate = create_test_eventcandidate("/test/42", json!({"value": 1})); @@ -140,12 +140,12 @@ async fn write_event_with_is_subject_on_event_id_condition_on_empty_subject() { }], ) .await; - assert!(result.is_err(), "Expected an error, but got: {:?}", result); + assert!(result.is_err(), "Expected an error, but got: {result:?}"); } #[tokio::test] async fn write_event_with_is_subject_on_event_id_condition_on_non_empty_subject_correct_id() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidate = create_test_eventcandidate("/test", json!({"value": 1})); @@ -164,12 +164,12 @@ async fn write_event_with_is_subject_on_event_id_condition_on_non_empty_subject_ }], ) .await; - assert!(result.is_ok(), "Writing the event failed: {:?}", result); + assert!(result.is_ok(), "Writing the event failed: {result:?}"); } #[tokio::test] async fn write_event_with_is_subject_on_event_id_condition_on_non_empty_subject_wrong_id() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidate = create_test_eventcandidate("/test", json!({"value": 1})); @@ -188,12 +188,12 @@ async fn write_event_with_is_subject_on_event_id_condition_on_non_empty_subject_ }], ) .await; - assert!(result.is_err(), "Expected an error, but got: {:?}", result); + assert!(result.is_err(), "Expected an error, but got: {result:?}"); } #[tokio::test] async fn write_events_with_is_subject_on_event_id_condition_on_empty_subject() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidates = vec![ @@ -209,12 +209,12 @@ async fn write_events_with_is_subject_on_event_id_condition_on_empty_subject() { }], ) .await; - assert!(result.is_err(), "Expected an error, but got: {:?}", result); + assert!(result.is_err(), "Expected an error, but got: {result:?}"); } #[tokio::test] async fn write_events_with_is_eventql_true_condition() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event_candidates = vec![ @@ -229,12 +229,12 @@ async fn write_events_with_is_eventql_true_condition() { }], ) .await; - assert!(result.is_ok(), "Expected an ok, but got: {:?}", result); + assert!(result.is_ok(), "Expected an ok, but got: {result:?}"); } #[tokio::test] async fn write_events_with_is_subject_on_event_id_condition_on_non_empty_subject_correct_id() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let fill_event_candidate = create_test_eventcandidate("/test", json!({"value": 1})); @@ -257,12 +257,12 @@ async fn write_events_with_is_subject_on_event_id_condition_on_non_empty_subject }], ) .await; - assert!(result.is_ok(), "Writing the events failed: {:?}", result); + assert!(result.is_ok(), "Writing the events failed: {result:?}"); } #[tokio::test] async fn write_events_with_is_subject_on_event_id_condition_on_non_empty_subject_wrong_id() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let fill_event_candidate = create_test_eventcandidate("/test", json!({"value": 1})); @@ -285,12 +285,12 @@ async fn write_events_with_is_subject_on_event_id_condition_on_non_empty_subject }], ) .await; - assert!(result.is_err(), "Expected an error, but got: {:?}", result); + assert!(result.is_err(), "Expected an error, but got: {result:?}"); } #[tokio::test] async fn write_single_event_with_traceparent() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event = EventCandidate::builder() .source("https://www.eventsourcingdb.io".to_string()) @@ -302,7 +302,7 @@ async fn write_single_event_with_traceparent() { }) .build(); let result = client.write_events(vec![event.clone()], vec![]).await; - assert!(result.is_ok(), "Failed to write events: {:?}", result); + assert!(result.is_ok(), "Failed to write events: {result:?}"); let mut response = result.unwrap(); assert_eq!(response.len(), 1, "Expected one event in the response"); let response_event = response.pop().unwrap(); @@ -312,7 +312,7 @@ async fn write_single_event_with_traceparent() { #[tokio::test] async fn write_single_event_with_traceparent_and_state() { - let container = Container::start_default().await.unwrap(); + let container = create_test_container().await; let client = container.get_client().await.unwrap(); let event = EventCandidate::builder() .source("https://www.eventsourcingdb.io".to_string()) @@ -325,12 +325,12 @@ async fn write_single_event_with_traceparent_and_state() { }) .build(); let result = client.write_events(vec![event.clone()], vec![]).await; - assert!(result.is_ok(), "Failed to write events: {:?}", result); + assert!(result.is_ok(), "Failed to write events: {result:?}"); let mut response = result.unwrap(); assert_eq!(response.len(), 1, "Expected one event in the response"); let response_event = response.pop().unwrap(); - println!("Response event: {:?}", response_event); + println!("Response event: {response_event:?}"); assert_event_match_eventcandidate(&response_event, &event, None, None); }