couchbase 4.2.0 → 4.2.2

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

@@ -282,6 +282,7 @@ TEST_CASE("integration: get with projections and json transcoder", "[integration
         REQUIRE(resp.mutation_token().has_value());
     }
 
+    SECTION("all fields present")
     {
         auto [ctx, resp] = collection.get(id, couchbase::get_options{}.project({ "username", "full_name" })).get();
         REQUIRE_SUCCESS(ctx.ec());
@@ -293,6 +294,19 @@ TEST_CASE("integration: get with projections and json transcoder", "[integration
         REQUIRE(light_albert.birth_year != albert.birth_year);
         REQUIRE(light_albert.birth_year == 0);
     }
+
+    SECTION("with non-existent field in projections")
+    {
+        auto [ctx, resp] = collection.get(id, couchbase::get_options{}.project({ "username", "full_name", "non_existent_field" })).get();
+        REQUIRE_SUCCESS(ctx.ec());
+        REQUIRE_FALSE(resp.cas().empty());
+        auto light_albert = resp.content_as<profile>();
+        REQUIRE_FALSE(light_albert == albert);
+        REQUIRE(light_albert.username == albert.username);
+        REQUIRE(light_albert.full_name == albert.full_name);
+        REQUIRE(light_albert.birth_year != albert.birth_year);
+        REQUIRE(light_albert.birth_year == 0);
+    }
 }
 
 TEST_CASE("integration: get_and_touch and json transcoder", "[integration]")

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

@@ -14,13 +14,13 @@
  *   limitations under the License.
  */
 
-#include "test_helper.hxx"
-#include "utils/transactions_env.h"
+#include "test_helper_integration.hxx"
 
 #include "core/transactions/attempt_context_impl.hxx"
 
 #include "core/transactions.hxx"
 #include "core/transactions/internal/transaction_context.hxx"
+#include "core/transactions/internal/utils.hxx"
 
 #include <spdlog/spdlog.h>
 
@@ -28,9 +28,8 @@
 #include <stdexcept>
 
 using namespace couchbase::core::transactions;
-static const tao::json::value tx_content{
-    { "some", "thing" },
-};
+static const tao::json::value tx_content{ { "some", "thing" } };
+static const std::vector<std::byte> tx_content_json = couchbase::core::utils::json::generate_binary(tx_content);
 
 void
 txn_completed(std::exception_ptr err, std::shared_ptr<std::promise<void>> barrier)
@@ -61,26 +60,32 @@ simple_txn_wrapper(transaction_context& tx, Handler&& handler)
             }
             return barrier->set_value(result);
         });
-        if (auto res = f.get()) {
-            return *res;
-        }
+        return *f.get();
     }
     throw std::runtime_error("exceeded max attempts and didn't timeout!");
 }
 
 TEST_CASE("transactions: can do simple transaction with transaction wrapper", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
+
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     tao::json::value new_content{
         { "some", "thing else" },
     };
-
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, tx_content));
+    {
+        couchbase::core::operations::upsert_request req{ id, tx_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
     transaction_context tx(txns);
-    auto txn_logic = [&id, &tx, &new_content]() {
-        tx.get(id, [&tx, &new_content](std::exception_ptr err, std::optional<transaction_get_result> res) {
+    auto txn_logic = [&id, &tx, new_content]() {
+        tx.get(id, [&tx, new_content](std::exception_ptr err, std::optional<transaction_get_result> res) {
             CHECK(res);
             CHECK_FALSE(err);
             tx.replace(*res,
@@ -92,23 +97,37 @@ TEST_CASE("transactions: can do simple transaction with transaction wrapper", "[
         });
     };
     auto result = simple_txn_wrapper(tx, txn_logic);
-    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: can do simple transaction with finalize", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
 
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, tx_content));
-    transaction_context tx(txns);
-    tx.new_attempt_context();
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     tao::json::value new_content{
         { "some", "thing else" },
     };
+    {
+        couchbase::core::operations::upsert_request req{ id, tx_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
+    transaction_context tx(txns);
+
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
+    tx.new_attempt_context();
     tx.get(id, [&tx, &new_content](std::exception_ptr err, std::optional<transaction_get_result> res) {
         CHECK(res);
         CHECK_FALSE(err);
@@ -119,73 +138,100 @@ TEST_CASE("transactions: can do simple transaction with finalize", "[transaction
                        CHECK_FALSE(err);
                    });
     });
-    tx.finalize(
-      [&barrier](std::optional<transaction_exception> err, std::optional<couchbase::transactions::transaction_result> /* result */) {
-          if (err) {
-              return barrier->set_exception(std::make_exception_ptr(*err));
-          }
-          return barrier->set_value();
-      });
+    tx.finalize([&barrier](std::optional<transaction_exception> err, std::optional<couchbase::transactions::transaction_result>) {
+        if (err) {
+            return barrier->set_exception(std::make_exception_ptr(*err));
+        }
+        return barrier->set_value();
+    });
     f.get();
-    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: can do simple transaction explicit commit", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
 
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, tx_content));
-    transaction_context tx(txns);
-    tx.new_attempt_context();
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     tao::json::value new_content{
         { "some", "thing else" },
     };
+    {
+        couchbase::core::operations::upsert_request req{ id, tx_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
+    transaction_context tx(txns);
+
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
+    tx.new_attempt_context();
     tx.get(id, [&tx, &new_content, &barrier](std::exception_ptr err, std::optional<transaction_get_result> res) {
         CHECK(res);
         CHECK_FALSE(err);
         tx.replace(*res,
                    couchbase::core::utils::json::generate_binary(new_content),
-                   [&tx, &barrier](std::exception_ptr err, std::optional<transaction_get_result> replaced) {
+                   [&tx, barrier](std::exception_ptr err, std::optional<transaction_get_result> replaced) {
                        CHECK(replaced);
                        CHECK_FALSE(err);
-                       tx.commit([&barrier](std::exception_ptr err) {
+                       tx.commit([barrier](std::exception_ptr err) {
                            CHECK_FALSE(err);
                            txn_completed(err, barrier);
                        });
                    });
     });
     f.get();
-    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: can do rollback simple transaction", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
 
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, tx_content));
-    transaction_context tx(txns);
-    tx.new_attempt_context();
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     tao::json::value new_content{
         { "some", "thing else" },
     };
+    {
+        couchbase::core::operations::upsert_request req{ id, tx_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
+    transaction_context tx(txns);
+
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
+    tx.new_attempt_context();
     tx.get(id, [&tx, &new_content, &barrier](std::exception_ptr err, std::optional<transaction_get_result> res) {
         CHECK(res);
         CHECK_FALSE(err);
         tx.replace(*res,
                    couchbase::core::utils::json::generate_binary(new_content),
-                   [&tx, &barrier](std::exception_ptr err, std::optional<transaction_get_result> replaced) {
+                   [&tx, barrier](std::exception_ptr err, std::optional<transaction_get_result> replaced) {
                        CHECK(replaced);
                        CHECK_FALSE(err);
                        // now rollback
-                       tx.rollback([&barrier](std::exception_ptr err) {
+                       tx.rollback([barrier](std::exception_ptr err) {
                            CHECK_FALSE(err); // no error rolling back
                            barrier->set_value();
                        });
@@ -198,18 +244,31 @@ TEST_CASE("transactions: can do rollback simple transaction", "[transactions]")
 
 TEST_CASE("transactions: can get insert errors", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
 
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, tx_content));
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
+    tao::json::value new_content{
+        { "some", "thing else" },
+    };
+    {
+        couchbase::core::operations::upsert_request req{ id, tx_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
     transaction_context tx(txns);
-    tx.new_attempt_context();
+
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
+    tx.new_attempt_context();
+
     tx.insert(id,
               couchbase::core::utils::json::generate_binary(tx_content),
-              [&barrier](std::exception_ptr err, std::optional<transaction_get_result> result) {
+              [barrier](std::exception_ptr err, std::optional<transaction_get_result> result) {
                   // this should result in a transaction_operation_failed exception since it already exists, so lets check it
                   CHECK(err);
                   CHECK_FALSE(result);
@@ -219,28 +278,40 @@ TEST_CASE("transactions: can get insert errors", "[transactions]")
                       barrier->set_value();
                   }
               });
-    CHECK_THROWS_AS(f.get(), transaction_operation_failed);
-    CHECK_THROWS_AS(tx.existing_error(), transaction_operation_failed);
+    CHECK_THROWS_AS(f.get(), couchbase::core::transactions::document_exists);
+    REQUIRE_NOTHROW(tx.existing_error());
 }
 
 TEST_CASE("transactions: can get remove errors", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
+
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
 
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, tx_content));
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
+    tao::json::value new_content{
+        { "some", "thing else" },
+    };
+    {
+        couchbase::core::operations::upsert_request req{ id, tx_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
     transaction_context tx(txns);
-    tx.new_attempt_context();
+
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
+    tx.new_attempt_context();
     tx.get(id, [&tx, &barrier](std::exception_ptr err, std::optional<transaction_get_result> result) {
         // this should result in a transaction_operation_failed exception since it already exists, so lets check it
         CHECK_FALSE(err);
         CHECK(result);
         // make a cas mismatch error
         result->cas(100);
-        tx.remove(*result, [&barrier](std::exception_ptr err) {
+        tx.remove(*result, [barrier](std::exception_ptr err) {
             CHECK(err);
             if (err) {
                 barrier->set_exception(err);
@@ -255,15 +326,28 @@ TEST_CASE("transactions: can get remove errors", "[transactions]")
 
 TEST_CASE("transactions: can get replace errors", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
+
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
 
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, tx_content));
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
+    tao::json::value new_content{
+        { "some", "thing else" },
+    };
+    {
+        couchbase::core::operations::upsert_request req{ id, tx_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
     transaction_context tx(txns);
-    tx.new_attempt_context();
+
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
+    tx.new_attempt_context();
+
     tx.get(id, [&tx, &barrier](std::exception_ptr err, std::optional<transaction_get_result> result) {
         // this should result in a transaction_operation_failed exception since it already exists, so lets check it
         CHECK_FALSE(err);
@@ -272,7 +356,7 @@ TEST_CASE("transactions: can get replace errors", "[transactions]")
         result->cas(100);
         tx.replace(*result,
                    couchbase::core::utils::json::generate_binary(tx_content),
-                   [&barrier](std::exception_ptr err, std::optional<transaction_get_result> result) {
+                   [barrier](std::exception_ptr err, std::optional<transaction_get_result> result) {
                        CHECK(err);
                        CHECK_FALSE(result);
                        if (err) {
@@ -288,20 +372,30 @@ TEST_CASE("transactions: can get replace errors", "[transactions]")
 
 TEST_CASE("transactions: RYOW get after insert", "[transactions]")
 {
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
+
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
 
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     transaction_context tx(txns);
+
+    auto barrier = std::make_shared<std::promise<void>>();
+    auto f = barrier->get_future();
     tx.new_attempt_context();
-    auto logic = [&tx, &id]() {
+
+    auto logic = [barrier, &tx, &id]() {
         tx.insert(id,
                   couchbase::core::utils::json::generate_binary(tx_content),
-                  [&tx, &id](std::exception_ptr err, std::optional<transaction_get_result> res) {
+                  [&tx, &id, barrier](std::exception_ptr err, std::optional<transaction_get_result> res) {
                       CHECK_FALSE(err);
                       CHECK(res);
-                      tx.get(id, [](std::exception_ptr err, std::optional<transaction_get_result> res) {
+                      tx.get(id, [barrier](std::exception_ptr err, std::optional<transaction_get_result> res) {
                           CHECK_FALSE(err);
                           CHECK(res->content<tao::json::value>() == tx_content);
+                          barrier->set_value();
                       });
                   });
     };
@@ -311,14 +405,19 @@ TEST_CASE("transactions: RYOW get after insert", "[transactions]")
 
 TEST_CASE("transactions: can get get errors", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
+
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
 
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     transaction_context tx(txns);
-    tx.new_attempt_context();
+
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
+    tx.new_attempt_context();
     tx.get(id, [&barrier](std::exception_ptr err, std::optional<transaction_get_result> result) {
         // this should result in a transaction_operation_failed exception since it already exists, so lets check it
         CHECK(err);
@@ -335,18 +434,28 @@ TEST_CASE("transactions: can get get errors", "[transactions]")
 
 TEST_CASE("transactions: can do query", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
-
+    test::utils::integration_test_guard integration;
+
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
+
+    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, tx_content_json };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+    }
     transaction_context tx(txns);
-    tx.new_attempt_context();
+
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
-    REQUIRE(TransactionsTestEnvironment::upsert_doc(id, tx_content));
+    tx.new_attempt_context();
+
     auto query = fmt::format("SELECT * FROM `{}` USE KEYS '{}'", id.bucket(), id.key());
-    transaction_query_options opts;
-    tx.query(query, opts, [&barrier](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
+    couchbase::transactions::transaction_query_options opts;
+    tx.query(query, opts, [barrier](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
         // this should result in a transaction_operation_failed exception since the doc isn't there
         CHECK(payload);
         CHECK_FALSE(err);
@@ -362,19 +471,24 @@ TEST_CASE("transactions: can do query", "[transactions]")
 
 TEST_CASE("transactions: can see some query errors but no transactions failed", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
+    test::utils::integration_test_guard integration;
 
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("txn") };
     transaction_context tx(txns);
-    tx.new_attempt_context();
+
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
-    transaction_query_options opts;
+    tx.new_attempt_context();
+    couchbase::transactions::transaction_query_options opts;
     tx.query("jkjkjl;kjlk;  jfjjffjfj",
              opts,
              [&barrier](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
-                 // this should result in a query_exception since the query isn't parseable.
+                 // this should result in a op_exception since the query isn't parseable.
                  CHECK(err);
                  CHECK_FALSE(payload);
                  if (err) {
@@ -386,39 +500,51 @@ TEST_CASE("transactions: can see some query errors but no transactions failed",
     try {
         f.get();
         FAIL("expected future to throw exception");
-    } catch (const query_exception&) {
-
+    } catch (const op_exception&) {
+        // eat the expected op_exception
     } catch (...) {
         auto e = std::current_exception();
         std::cout << "got " << typeid(e).name() << std::endl;
-        FAIL("expected query_exception to be thrown from the future");
+        FAIL("expected op_exception to be thrown from the future");
     }
     REQUIRE_NOTHROW(tx.existing_error());
 }
 
 TEST_CASE("transactions: can set per transaction config", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
-    auto id = TransactionsTestEnvironment::get_document_id();
-    couchbase::transactions::per_transaction_config per_txn_cfg;
-    per_txn_cfg.scan_consistency(couchbase::query_scan_consistency::not_bounded);
-    per_txn_cfg.expiration_time(std::chrono::milliseconds(1)).kv_timeout(std::chrono::milliseconds(2));
-    per_txn_cfg.durability_level(couchbase::durability_level::none);
+    test::utils::integration_test_guard integration;
+
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
+
+    auto barrier = std::make_shared<std::promise<void>>();
+    auto f = barrier->get_future();
+    couchbase::transactions::transaction_options per_txn_cfg;
+    per_txn_cfg.scan_consistency(couchbase::query_scan_consistency::not_bounded)
+      .expiration_time(std::chrono::milliseconds(1))
+      .kv_timeout(std::chrono::milliseconds(2))
+      .durability_level(couchbase::durability_level::none);
     transaction_context tx(txns, per_txn_cfg);
-    REQUIRE(tx.config().durability_level() == per_txn_cfg.durability_level());
-    REQUIRE(tx.config().kv_timeout() == per_txn_cfg.kv_timeout());
-    REQUIRE(tx.config().expiration_time() == per_txn_cfg.expiration_time());
-    REQUIRE(tx.config().scan_consistency() == per_txn_cfg.scan_consistency());
+    REQUIRE(tx.config().level == per_txn_cfg.durability_level());
+    REQUIRE(tx.config().kv_timeout == per_txn_cfg.kv_timeout());
+    REQUIRE(tx.config().expiration_time == per_txn_cfg.expiration_time());
+    REQUIRE(tx.config().query_config.scan_consistency == per_txn_cfg.scan_consistency());
 }
 
 TEST_CASE("transactions: can not per transactions config", "[transactions]")
 {
-    auto cluster = TransactionsTestEnvironment::get_cluster();
-    auto txns = TransactionsTestEnvironment::get_transactions();
+    test::utils::integration_test_guard integration;
+
+    auto cluster = integration.cluster;
+    couchbase::core::transactions::transactions txns(
+      cluster, couchbase::transactions::transactions_config().expiration_time(std::chrono::seconds(2)));
+
+    auto barrier = std::make_shared<std::promise<void>>();
+    auto f = barrier->get_future();
     transaction_context tx(txns);
-    REQUIRE(tx.config().durability_level() == txns.config().durability_level());
-    REQUIRE(tx.config().kv_timeout() == txns.config().kv_timeout());
-    REQUIRE(tx.config().expiration_time() == txns.config().expiration_time());
-    REQUIRE(tx.config().scan_consistency() == txns.config().scan_consistency());
+    REQUIRE(tx.config().level == txns.config().level);
+    REQUIRE(tx.config().kv_timeout == txns.config().kv_timeout);
+    REQUIRE(tx.config().expiration_time == txns.config().expiration_time);
+    REQUIRE(tx.config().query_config.scan_consistency == txns.config().query_config.scan_consistency);
 }