couchbase 4.2.0 → 4.2.1

package/deps/couchbase-cxx-client/test/test_transaction_transaction_simple_async.cxx

@@ -14,12 +14,9 @@
  *   limitations under the License.
  */
 
-#include "simple_object.hxx"
-#include "test_helper.hxx"
-
 #include "core/transactions/attempt_context_impl.hxx"
-
-#include "utils/transactions_env.h"
+#include "simple_object.hxx"
+#include "test_helper_integration.hxx"
 
 #include <spdlog/spdlog.h>
 
@@ -33,6 +30,16 @@ static const tao::json::value async_content{
     { "some", "thing" },
 };
 
+couchbase::transactions::transactions_config
+get_conf()
+{
+    couchbase::transactions::transactions_config cfg{};
+    cfg.expiration_time(std::chrono::seconds(1));
+    return cfg;
+}
+
+static const auto async_content_json = couchbase::core::utils::json::generate_binary(async_content);
+
 void
 txn_completed(std::optional<transaction_exception> err,
               std::optional<couchbase::transactions::transaction_result> /* result */,
@@ -47,15 +54,22 @@ txn_completed(std::optional<transaction_exception> err,
 
 TEST_CASE("transactions: async get", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
     auto cb_called = std::make_shared<std::atomic<bool>>(false);
 
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
-    txns.run(
+    txn.run(
       [id, cb_called](async_attempt_context& ctx) {
           ctx.get(id, [cb_called](std::exception_ptr err, std::optional<transaction_get_result> res) {
               if (!err) {
@@ -72,14 +86,16 @@ TEST_CASE("transactions: async get", "[transactions]")
     f.get();
 }
 
-TEST_CASE("transactions: can't get from unknown bucket", "[transactions]")
+TEST_CASE("transactions: can't get from unopened bucket", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    couchbase::core::document_id bad_id{ "secBucket", "_default", "default", uid_generator::next() };
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+    couchbase::core::document_id bad_id{ "secBucket", "_default", "default", test::utils::uniq_id("txns") };
     auto cb_called = std::make_shared<std::atomic<bool>>(false);
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
-    txns.run(
+    txn.run(
       [&bad_id, cb_called, barrier](async_attempt_context& ctx) {
           ctx.get(bad_id, [cb_called, barrier](std::exception_ptr err, std::optional<transaction_get_result> result) {
               cb_called->store(true);
@@ -97,16 +113,19 @@ TEST_CASE("transactions: can't get from unknown bucket", "[transactions]")
 
 TEST_CASE("transactions: async get fail", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto cb_called = std::make_shared<std::atomic<bool>>(false);
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
     try {
-        txns.run(
+        txn.run(
           [cb_called, id](async_attempt_context& ctx) {
-              ctx.get(id, [cb_called](std::exception_ptr err, std::optional<transaction_get_result> /* res */) {
+              ctx.get(id, [cb_called](std::exception_ptr err, std::optional<transaction_get_result>) {
                   // should be an error
                   CHECK(err);
                   cb_called->store(true);
@@ -119,7 +138,7 @@ TEST_CASE("transactions: async get fail", "[transactions]")
         f.get();
         FAIL("expected transaction_exception!");
     } catch (const transaction_exception& e) {
-        // nothing to do here, but make sure
+        // nothing to do here, but make sure cb was called, and the txn failed.
         REQUIRE(cb_called->load());
         REQUIRE(e.type() == failure_type::FAIL);
     } catch (const std::exception&) {
@@ -129,15 +148,24 @@ TEST_CASE("transactions: async get fail", "[transactions]")
 
 TEST_CASE("transactions: async remove fail", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
-    auto cb_called = std::make_shared<std::atomic<bool>>(false);
+
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
+    auto cb_called = std::make_shared<std::atomic<bool>>(false);
+
     try {
-        txns.run(
+        txn.run(
           [cb_called, id](async_attempt_context& ctx) {
               ctx.get(id, [&ctx, cb_called](std::exception_ptr err, std::optional<transaction_get_result> res) {
                   // let's just change the cas to make it fail, which it should
@@ -164,13 +192,16 @@ TEST_CASE("transactions: async remove fail", "[transactions]")
 
 TEST_CASE("transactions: RYOW on insert", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto cb_called = std::make_shared<std::atomic<bool>>(false);
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
-    txns.run(
+    txn.run(
       [cb_called, id](async_attempt_context& ctx) {
           ctx.insert(id, async_content, [&ctx, cb_called, id](std::exception_ptr err, std::optional<transaction_get_result> res) {
               CHECK_FALSE(err);
@@ -195,14 +226,21 @@ TEST_CASE("transactions: RYOW on insert", "[transactions]")
 
 TEST_CASE("transactions: async remove", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
-    auto cb_called = std::make_shared<std::atomic<bool>>(false);
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
-    txns.run(
+    auto cb_called = std::make_shared<std::atomic<bool>>(false);
+    txn.run(
       [cb_called, id](async_attempt_context& ctx) {
           ctx.get(id, [&ctx, cb_called](std::exception_ptr err, std::optional<transaction_get_result> res) {
               if (!err) {
@@ -219,27 +257,33 @@ TEST_CASE("transactions: async remove", "[transactions]")
       });
     f.get();
     REQUIRE(cb_called->load());
-    try {
-        TransactionsTestEnvironment::get_doc(id);
-        FAIL("expected get_doc to raise client exception");
-    } catch (const client_error& e) {
-        REQUIRE(e.res()->ec == couchbase::errc::key_value::document_not_found);
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
     }
 }
 
 TEST_CASE("transactions: async replace", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
+    auto barrier = std::make_shared<std::promise<void>>();
+    auto f = barrier->get_future();
+    auto cb_called = std::make_shared<std::atomic<bool>>(false);
     const tao::json::value new_content{
         { "shiny", "and new" },
     };
-    auto cb_called = std::make_shared<std::atomic<bool>>(false);
-    auto barrier = std::make_shared<std::promise<void>>();
-    auto f = barrier->get_future();
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
-    txns.run(
+    txn.run(
       [cb_called, &new_content, id](async_attempt_context& ctx) {
           ctx.get(id, [&ctx, &new_content, cb_called](std::exception_ptr err, std::optional<transaction_get_result> res) {
               if (!err) {
@@ -261,34 +305,45 @@ TEST_CASE("transactions: async replace", "[transactions]")
       });
     f.get();
     REQUIRE(cb_called->load());
-    auto content = TransactionsTestEnvironment::get_doc(id).content_as<tao::json::value>();
-    REQUIRE(content == new_content);
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(resp.value == couchbase::core::utils::json::generate_binary(new_content));
+    }
 }
 
 TEST_CASE("transactions: async replace fail", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
+    auto barrier = std::make_shared<std::promise<void>>();
+    auto f = barrier->get_future();
+    auto cb_called = std::make_shared<std::atomic<bool>>(false);
     const tao::json::value new_content{
         { "shiny", "and new" },
     };
-    auto cb_called = std::make_shared<std::atomic<bool>>(false);
-    auto barrier = std::make_shared<std::promise<void>>();
-    auto f = barrier->get_future();
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
+
     try {
-        txns.run(
+        txn.run(
           [cb_called, &new_content, id](async_attempt_context& ctx) {
               ctx.get(id, [&ctx, &new_content, cb_called](std::exception_ptr err, std::optional<transaction_get_result> res) {
                   if (!err) {
-                      ctx.replace(
-                        *res, new_content, [cb_called](std::exception_ptr err, std::optional<transaction_get_result> /* result */) {
-                            if (!err) {
-                                cb_called->store(true);
-                                throw std::runtime_error("I wanna roll back");
-                            }
-                        });
+                      ctx.replace(*res, new_content, [cb_called](std::exception_ptr err, std::optional<transaction_get_result>) {
+                          if (!err) {
+                              cb_called->store(true);
+                              throw std::runtime_error("I wanna roll back");
+                          }
+                      });
                   }
               });
           },
@@ -298,23 +353,30 @@ TEST_CASE("transactions: async replace fail", "[transactions]")
           });
         f.get();
         FAIL("expected exception");
-    } catch (const transaction_exception& e) {
+    } catch (const transaction_exception&) {
         REQUIRE(cb_called->load());
-        auto content = TransactionsTestEnvironment::get_doc(id).content_as<tao::json::value>();
-        REQUIRE(content == async_content);
-        REQUIRE(e.type() == failure_type::FAIL);
+        {
+            couchbase::core::operations::get_request req{ id };
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_SUCCESS(resp.ctx.ec());
+            REQUIRE(resp.value == async_content_json);
+        }
     };
 }
 
 TEST_CASE("transactions: async insert", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
-    auto cb_called = std::make_shared<std::atomic<bool>>(false);
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
-    txns.run(
+    auto cb_called = std::make_shared<std::atomic<bool>>(false);
+
+    txn.run(
       [cb_called, id](async_attempt_context& ctx) {
           ctx.insert(id, async_content, [cb_called](std::exception_ptr err, std::optional<transaction_get_result> res) {
               if (!err) {
@@ -329,21 +391,30 @@ TEST_CASE("transactions: async insert", "[transactions]")
       });
     f.get();
     REQUIRE(cb_called->load());
-    REQUIRE(TransactionsTestEnvironment::get_doc(id).content_as<tao::json::value>() == async_content);
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(resp.value == async_content_json);
+    }
 }
 
-TEST_CASE("transactions: async insert fail", "[transactions]")
+TEST_CASE("transactions: async insert can be rolled back", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
     auto cb_called = std::make_shared<std::atomic<bool>>(false);
+
     try {
-        txns.run(
+        txn.run(
           [cb_called, id, barrier](async_attempt_context& ctx) {
-              ctx.insert(id, async_content, [cb_called](std::exception_ptr err, std::optional<transaction_get_result> /* res */) {
+              ctx.insert(id, async_content, [cb_called](std::exception_ptr err, std::optional<transaction_get_result>) {
                   if (!err) {
                       cb_called->store(true);
                       throw std::runtime_error("I wanna rollback");
@@ -357,35 +428,40 @@ TEST_CASE("transactions: async insert fail", "[transactions]")
           });
         f.get();
         FAIL("Expected exception");
-    } catch (const transaction_exception& e) {
+    } catch (const transaction_exception&) {
         REQUIRE(cb_called->load());
-        REQUIRE(e.type() == failure_type::FAIL);
-        try {
-            TransactionsTestEnvironment::get_doc(id);
-            FAIL("expected get_doc to raise client exception");
-        } catch (const client_error& e) {
-            REQUIRE(e.res()->ec == couchbase::errc::key_value::document_not_found);
+        {
+            couchbase::core::operations::get_request req{ id };
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
         }
     }
 }
-
 TEST_CASE("transactions: async query", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
-    auto id = TransactionsTestEnvironment::get_document_id();
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
     auto f = barrier->get_future();
+    auto cb_called = std::make_shared<std::atomic<bool>>(false);
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
     auto query_called = std::make_shared<std::atomic<bool>>(false);
-    txns.run(
+    txn.run(
       [query_called, id](async_attempt_context& ctx) {
           auto query = fmt::format("UPDATE `{}` USE KEYS '{}' SET `some` = 'thing else'", id.bucket(), id.key());
-          ctx.query(query,
-                    [query_called](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> /* payload */) {
-                        if (!err) {
-                            query_called->store(true);
-                        }
-                    });
+          ctx.query(query, [query_called](std::exception_ptr err, std::optional<couchbase::core::operations::query_response>) {
+              if (!err) {
+                  query_called->store(true);
+              }
+          });
       },
       [query_called, barrier](std::optional<transaction_exception> err, std::optional<couchbase::transactions::transaction_result> result) {
           CHECK(query_called->load());
@@ -394,39 +470,50 @@ TEST_CASE("transactions: async query", "[transactions]")
       });
     f.get();
     REQUIRE(query_called->load());
-    auto content = TransactionsTestEnvironment::get_doc(id).content_as<tao::json::value>();
-    REQUIRE(content["some"].as<std::string>() == std::string("thing else"));
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(couchbase::core::utils::json::parse_binary(resp.value)["some"].as<std::string>() == std::string("thing else"));
+    }
 }
 
 TEST_CASE("transactions: multiple racing queries", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
-    auto id = TransactionsTestEnvironment::get_document_id();
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
     auto f = barrier->get_future();
+    auto cb_called = std::make_shared<std::atomic<bool>>(false);
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
+
     auto query_called = std::make_shared<std::atomic<int>>(0);
-    txns.run(
+    txn.run(
       [query_called, id](async_attempt_context& ctx) {
           auto query = fmt::format("UPDATE `{}` USE KEYS '{}' SET `some` = 'thing else'", id.bucket(), id.key());
-          ctx.query(query,
-                    [query_called](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> /* payload */) {
-                        if (!err) {
-                            ++(*query_called);
-                        }
-                    });
-          ctx.query(query,
-                    [query_called](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> /* payload */) {
-                        if (!err) {
-                            ++(*query_called);
-                        }
-                    });
-          ctx.query(query,
-                    [query_called](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> /* payload */) {
-                        if (!err) {
-                            ++(*query_called);
-                        }
-                    });
+          ctx.query(query, [query_called](std::exception_ptr err, std::optional<couchbase::core::operations::query_response>) {
+              if (!err) {
+                  ++(*query_called);
+              }
+          });
+          ctx.query(query, [query_called](std::exception_ptr err, std::optional<couchbase::core::operations::query_response>) {
+              if (!err) {
+                  ++(*query_called);
+              }
+          });
+          ctx.query(query, [query_called](std::exception_ptr err, std::optional<couchbase::core::operations::query_response>) {
+              if (!err) {
+                  ++(*query_called);
+              }
+          });
       },
       [query_called, barrier](std::optional<transaction_exception> err, std::optional<couchbase::transactions::transaction_result> result) {
           CHECK(3 == query_called->load());
@@ -435,29 +522,42 @@ TEST_CASE("transactions: multiple racing queries", "[transactions]")
       });
     f.get();
     REQUIRE(3 == query_called->load());
-    auto content = TransactionsTestEnvironment::get_doc(id).content_as<tao::json::value>();
-    REQUIRE(content["some"].as<std::string>() == std::string("thing else"));
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(couchbase::core::utils::json::parse_binary(resp.value)["some"].as<std::string>() == std::string("thing else"));
+    }
 }
 
 TEST_CASE("transactions: rollback async query", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
-    auto id = TransactionsTestEnvironment::get_document_id();
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
     auto f = barrier->get_future();
+    auto cb_called = std::make_shared<std::atomic<bool>>(false);
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
+
     auto query_called = std::make_shared<std::atomic<bool>>(false);
-    txns.run(
+    txn.run(
       [query_called, id](async_attempt_context& ctx) {
           auto query = fmt::format("UPDATE `{}` USE KEYS '{}' SET `some` = 'thing else'", id.bucket(), id.key());
-          ctx.query(query,
-                    [query_called](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> /* payload */) {
-                        if (!err) {
-                            query_called->store(true);
-                            // now rollback by throwing arbitrary exception
-                            throw 3;
-                        }
-                    });
+          ctx.query(query, [query_called](std::exception_ptr err, std::optional<couchbase::core::operations::query_response>) {
+              if (!err) {
+                  query_called->store(true);
+                  // now rollback by throwing arbitrary exception
+                  throw 3;
+              }
+          });
       },
       [query_called, barrier](std::optional<transaction_exception> err, std::optional<couchbase::transactions::transaction_result> result) {
           CHECK(query_called->load());
@@ -466,24 +566,38 @@ TEST_CASE("transactions: rollback async query", "[transactions]")
       });
     CHECK_THROWS_AS(f.get(), transaction_exception);
     REQUIRE(query_called->load());
-    REQUIRE(TransactionsTestEnvironment::get_doc(id).content_as<tao::json::value>() == async_content);
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(resp.value == async_content_json);
+    }
 }
 
 TEST_CASE("transactions: async KV get", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
+
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
-    auto id = TransactionsTestEnvironment::get_document_id();
     auto f = barrier->get_future();
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
+
     auto get_called = std::make_shared<std::atomic<bool>>(false);
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
-    txns.run(
+    txn.run(
       [get_called, &id](async_attempt_context& ctx) {
-          ctx.get(id, [get_called, &id, &ctx](std::exception_ptr /* err */, std::optional<transaction_get_result> /* result */) {
+          ctx.get(id, [get_called, &id, &ctx](std::exception_ptr, std::optional<transaction_get_result>) {
               auto query = fmt::format("UPDATE `{}` USE KEYS '{}' SET `some` = 'thing else'", id.bucket(), id.key());
               ctx.query(
-                query,
-                [get_called, &id, &ctx](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> /* payload */) {
+                query, [get_called, &id, &ctx](std::exception_ptr err, std::optional<couchbase::core::operations::query_response>) {
                     if (!err) {
                         ctx.get(id, [get_called](std::exception_ptr err, std::optional<transaction_get_result>) {
                             if (!err) {
@@ -501,24 +615,36 @@ TEST_CASE("transactions: async KV get", "[transactions]")
       });
     f.get();
     REQUIRE(get_called->load());
-    REQUIRE(TransactionsTestEnvironment::get_doc(id).content_as<tao::json::value>()["some"].as<std::string>() == "thing else");
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(couchbase::core::utils::json::parse_binary(resp.value)["some"].as<std::string>() == std::string("thing else"));
+    }
 }
 
 TEST_CASE("transactions: rollback async KV get", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
-    auto id = TransactionsTestEnvironment::get_document_id();
     auto f = barrier->get_future();
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
     auto get_called = std::make_shared<std::atomic<bool>>(false);
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
-    txns.run(
+    txn.run(
       [get_called, &id](async_attempt_context& ctx) {
-          ctx.get(id, [&ctx, get_called, &id](std::exception_ptr /* err */, std::optional<transaction_get_result> /* result */) {
+          ctx.get(id, [&ctx, get_called, &id](std::exception_ptr, std::optional<transaction_get_result>) {
               auto query = fmt::format("UPDATE `{}` USE KEYS '{}' SET `some` = 'thing else'", id.bucket(), id.key());
               ctx.query(
-                query,
-                [&ctx, get_called, &id](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> /* payload */) {
+                query, [&ctx, get_called, &id](std::exception_ptr err, std::optional<couchbase::core::operations::query_response>) {
                     if (!err) {
                         ctx.get(id, [get_called](std::exception_ptr err, std::optional<transaction_get_result>) {
                             if (!err) {
@@ -537,26 +663,33 @@ TEST_CASE("transactions: rollback async KV get", "[transactions]")
       });
     REQUIRE_THROWS_AS(f.get(), transaction_exception);
     REQUIRE(get_called->load());
-    REQUIRE(TransactionsTestEnvironment::get_doc(id).content_as<tao::json::value>()["some"].as<std::string>() == "thing");
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(resp.value == async_content_json);
+    }
 }
 
 TEST_CASE("transactions: async KV insert", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
-    auto id = TransactionsTestEnvironment::get_document_id();
     auto f = barrier->get_future();
     auto insert_called = std::make_shared<std::atomic<bool>>(false);
-    txns.run(
+    txn.run(
       [insert_called, id, barrier](async_attempt_context& ctx) {
           ctx.query("Select 'Yo' as greeting",
-                    [&ctx, insert_called, id, barrier](std::exception_ptr err,
-                                                       std::optional<couchbase::core::operations::query_response> /* resp */) {
+                    [&ctx, insert_called, id, barrier](std::exception_ptr err, std::optional<couchbase::core::operations::query_response>) {
                         if (!err) {
-                            ctx.insert(
-                              id, async_content, [insert_called](std::exception_ptr err, std::optional<transaction_get_result> /* res */) {
-                                  insert_called->store(!err);
-                              });
+                            ctx.insert(id, async_content, [insert_called](std::exception_ptr err, std::optional<transaction_get_result>) {
+                                insert_called->store(!err);
+                            });
                         }
                     });
       },
@@ -567,28 +700,35 @@ TEST_CASE("transactions: async KV insert", "[transactions]")
       });
     f.get();
     REQUIRE(insert_called->load());
-    REQUIRE(TransactionsTestEnvironment::get_doc(id).content_as<tao::json::value>() == async_content);
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(resp.value == async_content_json);
+    }
 }
 
 TEST_CASE("transactions: rollback async KV insert", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
-    auto id = TransactionsTestEnvironment::get_document_id();
     auto f = barrier->get_future();
     auto insert_called = std::make_shared<std::atomic<bool>>(false);
-    txns.run(
+    txn.run(
       [insert_called, id, barrier](async_attempt_context& ctx) {
           ctx.query("Select 'Yo' as greeting",
-                    [insert_called, &ctx, id, barrier](std::exception_ptr err,
-                                                       std::optional<couchbase::core::operations::query_response> /* resp */) {
+                    [insert_called, &ctx, id, barrier](std::exception_ptr err, std::optional<couchbase::core::operations::query_response>) {
                         if (!err) {
-                            ctx.insert(
-                              id, async_content, [insert_called](std::exception_ptr err, std::optional<transaction_get_result> /* res */) {
-                                  insert_called->store(!err);
-                                  // now roll it back
-                                  throw 3;
-                              });
+                            ctx.insert(id, async_content, [insert_called](std::exception_ptr err, std::optional<transaction_get_result>) {
+                                insert_called->store(!err);
+                                // now roll it back
+                                throw 3;
+                            });
                         }
                     });
       },
@@ -599,46 +739,52 @@ TEST_CASE("transactions: rollback async KV insert", "[transactions]")
       });
     REQUIRE_THROWS_AS(f.get(), transaction_exception);
     REQUIRE(insert_called->load());
-    try {
-        TransactionsTestEnvironment::get_doc(id);
-        FAIL("expected get_doc to raise client exception");
-    } catch (const client_error& e) {
-        REQUIRE(e.res()->ec == couchbase::errc::key_value::document_not_found);
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
     }
 }
 
 TEST_CASE("transactions: async KV replace", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
-    auto id = TransactionsTestEnvironment::get_document_id();
     auto f = barrier->get_future();
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
+
     tao::json::value new_content{
         { "some", "thing else" },
     };
     auto replace_called = std::make_shared<std::atomic<bool>>(false);
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
-    txns.run(
+    txn.run(
       [replace_called, &id, &new_content](async_attempt_context& ctx) {
           ctx.get(id, [replace_called, id, &ctx, &new_content](std::exception_ptr err, std::optional<transaction_get_result> result) {
               // do a query just to move into query mode.
               if (!err) {
                   CHECK(result);
                   auto query = fmt::format("SELECT * FROM `{}` USE KEYS '{}'", id.bucket(), id.key());
-                  ctx.query(query,
-                            [replace_called, &ctx, &new_content, doc = *result](
-                              std::exception_ptr err, std::optional<couchbase::core::operations::query_response> /* payload */) {
+                  ctx.query(
+                    query,
+                    [replace_called, &ctx, &new_content, doc = *result](std::exception_ptr err,
+                                                                        std::optional<couchbase::core::operations::query_response>) {
+                        if (!err) {
+                            ctx.replace(doc, new_content, [replace_called](std::exception_ptr err, std::optional<transaction_get_result>) {
                                 if (!err) {
-                                    ctx.replace(
-                                      doc,
-                                      new_content,
-                                      [replace_called](std::exception_ptr err, std::optional<transaction_get_result> /* result */) {
-                                          if (!err) {
-                                              replace_called->store(true);
-                                          }
-                                      });
+                                    replace_called->store(true);
                                 }
                             });
+                        }
+                    });
               }
           });
       },
@@ -650,42 +796,53 @@ TEST_CASE("transactions: async KV replace", "[transactions]")
       });
     f.get();
     REQUIRE(replace_called->load());
-    REQUIRE(TransactionsTestEnvironment::get_doc(id).content_as<tao::json::value>() == new_content);
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(resp.value == couchbase::core::utils::json::generate_binary(new_content));
+    }
 }
 
 TEST_CASE("transactions: rollback async KV replace", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
-    auto id = TransactionsTestEnvironment::get_document_id();
     auto f = barrier->get_future();
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
     tao::json::value new_content{
         { "some", "thing else" },
     };
     auto replace_called = std::make_shared<std::atomic<bool>>(false);
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
-    txns.run(
+    txn.run(
       [replace_called, &id, &new_content](async_attempt_context& ctx) {
           ctx.get(id, [replace_called, &ctx, &id, &new_content](std::exception_ptr err, std::optional<transaction_get_result> result) {
               // do a query just to move into query mode.
               if (!err) {
                   CHECK(result);
                   auto query = fmt::format("SELECT * FROM `{}` USE KEYS '{}'", id.bucket(), id.key());
-                  ctx.query(query,
-                            [replace_called, &ctx, &new_content, doc = *result](
-                              std::exception_ptr err, std::optional<couchbase::core::operations::query_response> /* payload */) {
+                  ctx.query(
+                    query,
+                    [replace_called, &ctx, &new_content, doc = *result](std::exception_ptr err,
+                                                                        std::optional<couchbase::core::operations::query_response>) {
+                        if (!err) {
+                            ctx.replace(doc, new_content, [replace_called](std::exception_ptr err, std::optional<transaction_get_result>) {
                                 if (!err) {
-                                    ctx.replace(
-                                      doc,
-                                      new_content,
-                                      [replace_called](std::exception_ptr err, std::optional<transaction_get_result> /* result */) {
-                                          if (!err) {
-                                              replace_called->store(true);
-                                              throw 3;
-                                          }
-                                      });
+                                    replace_called->store(true);
+                                    throw 3;
                                 }
                             });
+                        }
+                    });
               }
           });
       },
@@ -697,18 +854,33 @@ TEST_CASE("transactions: rollback async KV replace", "[transactions]")
       });
     REQUIRE_THROWS_AS(f.get(), transaction_exception);
     REQUIRE(replace_called->load());
-    REQUIRE(TransactionsTestEnvironment::get_doc(id).content_as<tao::json::value>() == async_content);
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(resp.value == async_content_json);
+    }
 }
 
 TEST_CASE("transactions: async KV remove", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
+
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
-    auto id = TransactionsTestEnvironment::get_document_id();
     auto f = barrier->get_future();
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
+
     auto remove_called = std::make_shared<std::atomic<bool>>(false);
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
-    txns.run(
+    txn.run(
       [remove_called, &id](async_attempt_context& ctx) {
           ctx.get(id, [remove_called, &ctx, &id](std::exception_ptr err, std::optional<transaction_get_result> result) {
               // do a query just to move into query mode.
@@ -717,7 +889,7 @@ TEST_CASE("transactions: async KV remove", "[transactions]")
                   auto query = fmt::format("SELECT * FROM `{}` USE KEYS '{}'", id.bucket(), id.key());
                   ctx.query(query,
                             [remove_called, &ctx, doc = *result](std::exception_ptr err,
-                                                                 std::optional<couchbase::core::operations::query_response> /* payload */) {
+                                                                 std::optional<couchbase::core::operations::query_response>) {
                                 if (!err) {
                                     ctx.remove(doc, [remove_called](std::exception_ptr err) {
                                         if (!err) {
@@ -737,23 +909,31 @@ TEST_CASE("transactions: async KV remove", "[transactions]")
       });
     f.get();
     REQUIRE(remove_called->load());
-    try {
-        TransactionsTestEnvironment::get_doc(id);
-        FAIL("expected get_doc to raise client exception");
-    } catch (const client_error& e) {
-        REQUIRE(e.res()->ec == couchbase::errc::key_value::document_not_found);
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
     }
 }
 
 TEST_CASE("transactions: rollback async KV remove", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
+    test::utils::integration_test_guard integration;
+
+    couchbase::core::transactions::transactions txn(integration.cluster, get_conf());
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     auto barrier = std::make_shared<std::promise<void>>();
-    auto id = TransactionsTestEnvironment::get_document_id();
     auto f = barrier->get_future();
+    {
+        couchbase::core::operations::upsert_request req{ id, async_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
+
     auto remove_called = std::make_shared<std::atomic<bool>>(false);
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, async_content));
-    txns.run(
+    txn.run(
       [remove_called, &id](async_attempt_context& ctx) {
           ctx.get(id, [remove_called, &id, &ctx](std::exception_ptr err, std::optional<transaction_get_result> result) {
               // do a query just to move into query mode.
@@ -762,7 +942,7 @@ TEST_CASE("transactions: rollback async KV remove", "[transactions]")
                   auto query = fmt::format("SELECT * FROM `{}` USE KEYS '{}'", id.bucket(), id.key());
                   ctx.query(query,
                             [remove_called, &ctx, doc = *result](std::exception_ptr err,
-                                                                 std::optional<couchbase::core::operations::query_response> /* payload */) {
+                                                                 std::optional<couchbase::core::operations::query_response>) {
                                 if (!err) {
                                     ctx.remove(doc, [remove_called](std::exception_ptr err) {
                                         REQUIRE_FALSE(err);
@@ -782,106 +962,11 @@ TEST_CASE("transactions: rollback async KV remove", "[transactions]")
       });
     REQUIRE_THROWS_AS(f.get(), transaction_exception);
     REQUIRE(remove_called->load());
-    REQUIRE(TransactionsTestEnvironment::get_doc(id).content_as<tao::json::value>() == async_content);
-}
-
-TEST_CASE("transactions: async get replace", "[transactions]")
-{
-    static constexpr std::size_t NUM_TXNS{ 2 };
-    tao::json::value doc1_content{
-        { "number", 0 },
-    };
-    tao::json::value doc2_content{
-        { "number", 200 },
-    };
-    auto id1 = TransactionsTestEnvironment::get_document_id();
-    auto id2 = TransactionsTestEnvironment::get_document_id();
-    TransactionsTestEnvironment::upsert_doc(id1, doc1_content);
-    TransactionsTestEnvironment::upsert_doc(id2, doc2_content);
-    auto txn = TransactionsTestEnvironment::get_transactions();
-    auto attempts = std::make_shared<std::atomic<uint32_t>>(0);
-    auto errors = std::make_shared<std::atomic<uint32_t>>(0);
-    auto txns = std::make_shared<std::atomic<uint32_t>>(0);
-    auto done = std::make_shared<std::atomic<bool>>(false);
-
-    uint32_t in_flight{ 0 };
-    std::condition_variable cv_in_flight;
-    std::condition_variable cv_txns_complete;
-    std::mutex mut;
-    while (!done->load()) {
-        std::unique_lock<std::mutex> lock(mut);
-        cv_in_flight.wait(lock, [&in_flight] { return in_flight < NUM_TXNS; });
-        in_flight++;
-        lock.unlock();
-        txn.run(
-          [attempts, done, id1, id2](async_attempt_context& ctx) {
-              ++(*attempts);
-              ctx.get(id1, [done, &ctx](std::exception_ptr err, std::optional<transaction_get_result> doc1) {
-                  if (!doc1 || err) {
-                      return;
-                  }
-                  auto content = doc1->content<tao::json::value>();
-                  auto count = content["number"].as<uint32_t>();
-                  if (count >= 200) {
-                      done->store(true);
-                      return;
-                  }
-                  content["number"] = ++count;
-                  ctx.replace(*doc1, content, [doc1](std::exception_ptr err, std::optional<transaction_get_result>) {
-                      if (!err) {
-                          // CHECK(doc1->cas() != doc1_updated->cas());
-                      }
-                  });
-              });
-              ctx.get(id2, [&done, &ctx](std::exception_ptr err, std::optional<transaction_get_result> doc2) {
-                  if (!doc2 || err) {
-                      return;
-                  }
-                  auto content = doc2->content<tao::json::value>();
-                  auto count = content["number"].as<uint32_t>();
-                  if (count <= 0) {
-                      done->store(true);
-                      return;
-                  }
-                  content["number"] = --count;
-                  ctx.replace(*doc2, content, [doc2](std::exception_ptr err, std::optional<transaction_get_result>) {
-                      if (!err) {
-                          // CHECK(doc2->cas() != doc2_updated->cas());
-                      }
-                  });
-              });
-          },
-          [txns, done, errors, &in_flight, &cv_in_flight, &cv_txns_complete, &mut](
-            std::optional<transaction_exception> err, std::optional<couchbase::transactions::transaction_result> /* result */) {
-              ++(*txns);
-              std::unique_lock<std::mutex> lock(mut);
-              in_flight--;
-              if (in_flight < NUM_TXNS) {
-                  cv_in_flight.notify_all();
-              }
-              if (in_flight == 0 && done->load()) {
-                  cv_txns_complete.notify_all();
-              }
-              lock.unlock();
-              if (err) {
-                  ++(*errors);
-              }
-          });
+    REQUIRE(remove_called->load());
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(resp.value == async_content_json);
     }
-
-    // wait till it is really done and committed that last one...
-    std::unique_lock<std::mutex> lock(mut);
-    cv_txns_complete.wait(lock, [&in_flight, done] { return (in_flight == 0 && done->load()); });
-    lock.unlock();
-    // now lets look at the final state of the docs:
-    auto doc1 = TransactionsTestEnvironment::get_doc(id1);
-    auto doc2 = TransactionsTestEnvironment::get_doc(id2);
-    REQUIRE(0 == doc2.content_as<tao::json::value>()["number"].as<uint32_t>());
-    REQUIRE(200 == doc1.content_as<tao::json::value>()["number"].as<uint32_t>());
-    // could be we have some txns that are successful, but did nothing as they noticed the count
-    // is at limits.  So at least 200 txns.
-    REQUIRE(txns->load() - errors->load() != 200);
-    // No way we don't have at least one conflict, so attempts should be much larger than txns.
-    REQUIRE(attempts->load() > 200);
-    std::cout << "attempts: " << attempts->load() << ", txns: " << txns->load() << ", errors: " << errors->load() << std::endl;
 }