couchbase 4.1.1 → 4.1.3

package/deps/couchbase-transactions-cxx/tests/transactions/simple_async_t.cpp

@@ -18,7 +18,7 @@
 #include "../../src/transactions/attempt_context_testing_hooks.hxx"
 #include "helpers.hxx"
 #include "transactions_env.h"
-#include <couchbase/errors.hxx>
+#include <couchbase/error_codes.hxx>
 #include <couchbase/transactions.hxx>
 #include <gtest/gtest.h>
 #include <spdlog/spdlog.h>
@@ -71,7 +71,7 @@ TEST(SimpleAsyncTxns, AsyncGet)
 TEST(SimpleAsyncTxns, CantGetFromUnknownBucket)
 {
     auto txns = TransactionsTestEnvironment::get_transactions();
-    couchbase::document_id bad_id{ "secBucket", "_default", "default", uid_generator::next() };
+    couchbase::core::document_id bad_id{ "secBucket", "_default", "default", uid_generator::next() };
     std::atomic<bool> cb_called{ false };
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
@@ -136,7 +136,7 @@ TEST(SimpleAsyncTxns, AsyncRemoveFail)
         txns.run(
           [&cb_called, id](async_attempt_context& ctx) {
               ctx.get(id, [&ctx, &cb_called](std::exception_ptr err, std::optional<transaction_get_result> res) {
-                  // lets just change the cas to make it fail, which it should
+                  // let's just change the cas to make it fail, which it should
                   // do until timeout
                   if (!err) {
                       res->cas(100);
@@ -170,7 +170,7 @@ TEST(SimpleAsyncTxns, RYOWOnInsert)
           ctx.insert(id, async_content, [&ctx, &cb_called, id](std::exception_ptr err, std::optional<transaction_get_result> res) {
               EXPECT_FALSE(err);
               EXPECT_TRUE(res);
-              ctx.get(id, [&ctx, &cb_called, id](std::exception_ptr err, std::optional<transaction_get_result> res) {
+              ctx.get(id, [&cb_called, id](std::exception_ptr err, std::optional<transaction_get_result> res) {
                   EXPECT_FALSE(err);
                   EXPECT_TRUE(res);
                   EXPECT_EQ(res->content<nlohmann::json>(), async_content);
@@ -218,7 +218,7 @@ TEST(SimpleAsyncTxns, AsyncRemove)
         TransactionsTestEnvironment::get_doc(id);
         FAIL() << "expected get_doc to raise client exception";
     } catch (const client_error& e) {
-        ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+        ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
     }
 }
 
@@ -354,7 +354,7 @@ TEST(SimpleAsyncTxns, AsyncInsertFail)
             TransactionsTestEnvironment::get_doc(id);
             FAIL() << "expected get_doc to raise client exception";
         } catch (const client_error& e) {
-            ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+            ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
         }
     }
 }
@@ -370,7 +370,7 @@ TEST(SimpleQueryAsyncTxns, AsyncQuery)
     std::atomic<bool> query_called = false;
     txns.run(
       [&query_called, &query](async_attempt_context& ctx) {
-          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
               if (!err) {
                   query_called = true;
               }
@@ -398,17 +398,17 @@ TEST(SimpleQueryAsyncTxns, MultipleRacingQueries)
     std::atomic<int> query_called = 0;
     txns.run(
       [&query_called, &query](async_attempt_context& ctx) {
-          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
               if (!err) {
                   query_called++;
               }
           });
-          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
               if (!err) {
                   query_called++;
               }
           });
-          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
               if (!err) {
                   query_called++;
               }
@@ -436,7 +436,7 @@ TEST(SimpleQueryAsyncTxns, RollbackAsyncQuery)
     std::atomic<bool> query_called = false;
     txns.run(
       [&query_called, &query](async_attempt_context& ctx) {
-          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
               if (!err) {
                   query_called = true;
                   // now rollback by throwing arbitrary exception
@@ -466,7 +466,7 @@ TEST(SimpleQueryAsyncTxns, AsyncKVGet)
     txns.run(
       [&get_called, &query, &id](async_attempt_context& ctx) {
           ctx.get(id, [&](std::exception_ptr err, std::optional<transaction_get_result> result) {
-              ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+              ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
                   if (!err) {
                       ctx.get(id, [&](std::exception_ptr err, std::optional<transaction_get_result> result) {
                           if (!err) {
@@ -499,7 +499,7 @@ TEST(SimpleQueryAsyncTxns, RollbackAsyncKVGet)
     txns.run(
       [&get_called, &query, &id](async_attempt_context& ctx) {
           ctx.get(id, [&](std::exception_ptr err, std::optional<transaction_get_result> result) {
-              ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+              ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
                   if (!err) {
                       ctx.get(id, [&](std::exception_ptr err, std::optional<transaction_get_result> result) {
                           if (!err) {
@@ -532,7 +532,7 @@ TEST(SimpleQueryAsyncTxns, AsyncKVInsert)
     txns.run(
       [&, barrier](async_attempt_context& ctx) {
           ctx.query("Select 'Yo' as greeting",
-                    [&, barrier](std::exception_ptr err, std::optional<couchbase::operations::query_response> resp) {
+                    [&, barrier](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> resp) {
                         if (!err) {
                             ctx.insert(id, async_content.dump(), [&](std::exception_ptr err, std::optional<transaction_get_result> res) {
                                 insert_called = !err;
@@ -560,7 +560,7 @@ TEST(SimpleQueryAsyncTxns, RollbackAsyncKVInsert)
     txns.run(
       [&, barrier](async_attempt_context& ctx) {
           ctx.query("Select 'Yo' as greeting",
-                    [&, barrier](std::exception_ptr err, std::optional<couchbase::operations::query_response> resp) {
+                    [&, barrier](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> resp) {
                         if (!err) {
                             ctx.insert(id, async_content.dump(), [&](std::exception_ptr err, std::optional<transaction_get_result> res) {
                                 insert_called = !err;
@@ -580,7 +580,7 @@ TEST(SimpleQueryAsyncTxns, RollbackAsyncKVInsert)
     try {
         TransactionsTestEnvironment::get_doc(id);
     } catch (const client_error& e) {
-        ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+        ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
     }
 }
 
@@ -601,7 +601,7 @@ TEST(SimpleQueryAsyncTxns, AsyncKVReplace)
               if (!err) {
                   EXPECT_TRUE(result);
                   ctx.query(
-                    query, [&, doc = *result](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+                    query, [&, doc = *result](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
                         if (!err) {
                             ctx.replace(doc, new_content, [&](std::exception_ptr err, std::optional<transaction_get_result> result) {
                                 if (!err) {
@@ -640,7 +640,7 @@ TEST(SimpleQueryAsyncTxns, RollbackAsyncKVReplace)
               if (!err) {
                   EXPECT_TRUE(result);
                   ctx.query(
-                    query, [&, doc = *result](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+                    query, [&, doc = *result](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
                         if (!err) {
                             ctx.replace(doc, new_content, [&](std::exception_ptr err, std::optional<transaction_get_result> result) {
                                 if (!err) {
@@ -679,7 +679,7 @@ TEST(SimpleQueryAsyncTxns, AsyncKVRemove)
               if (!err) {
                   EXPECT_TRUE(result);
                   ctx.query(query,
-                            [&, doc = *result](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+                            [&, doc = *result](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
                                 if (!err) {
                                     ctx.remove(doc, [&](std::exception_ptr err) {
                                         if (!err) {
@@ -701,7 +701,7 @@ TEST(SimpleQueryAsyncTxns, AsyncKVRemove)
     try {
         TransactionsTestEnvironment::get_doc(id);
     } catch (const client_error& e) {
-        ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+        ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
     }
 }
 TEST(SimpleQueryAsyncTxns, RollbackAsyncKVRemove)
@@ -720,7 +720,7 @@ TEST(SimpleQueryAsyncTxns, RollbackAsyncKVRemove)
               if (!err) {
                   EXPECT_TRUE(result);
                   ctx.query(query,
-                            [&, doc = *result](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+                            [&, doc = *result](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
                                 if (!err) {
                                     ctx.remove(doc, [&](std::exception_ptr err) {
                                         ASSERT_FALSE(err);

package/deps/couchbase-transactions-cxx/tests/transactions/simple_t.cpp

@@ -16,7 +16,7 @@
 
 #include "helpers.hxx"
 #include "transactions_env.h"
-#include <couchbase/errors.hxx>
+#include <couchbase/error_codes.hxx>
 #include <couchbase/transactions.hxx>
 #include <gtest/gtest.h>
 #include <spdlog/spdlog.h>
@@ -100,6 +100,195 @@ TEST(SimpleTransactions, CanGetReplace)
     ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
 }
 
+TEST(SimpleTransactions, CanUseCustomMetadataCollectionsPerTransaction)
+{
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    auto txn = TransactionsTestEnvironment::get_transactions();
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    per_transaction_config cfg;
+    cfg.custom_metadata_collection({ "secBucket" });
+    txn.run(cfg, [&](attempt_context& ctx) {
+        auto doc = ctx.get(id);
+        auto content = doc.content<nlohmann::json>();
+        content["another one"] = 1;
+        ctx.replace(doc, content);
+    });
+
+    // now add to the original content, and compare
+    c["another one"] = 1;
+    ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+}
+
+TEST(SimpleTransactions, NonExistentBucketInPerTxnCustomMetadataCollections)
+{
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    auto txn = TransactionsTestEnvironment::get_transactions();
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    per_transaction_config cfg;
+    cfg.expiration_time(std::chrono::seconds(1));
+    cfg.custom_metadata_collection({ "idontexist" });
+    try {
+        txn.run(cfg, [&](attempt_context& ctx) {
+            auto doc = ctx.get(id);
+            auto content = doc.content<nlohmann::json>();
+            content["another one"] = 1;
+            ctx.replace(doc, content);
+        });
+        FAIL() << "expected txn to throw a transaction_exception";
+    } catch (const transaction_exception& e) {
+        ASSERT_EQ(e.type(), failure_type::FAIL);
+    } catch (...) {
+        FAIL() << "expected transaction to throw a transaction_exception";
+    }
+    // check that doc content untouched
+    ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+}
+
+TEST(SimpleTransactions, NonExistentScopeInPerTxnCustomMetadataCollections)
+{
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    auto txn = TransactionsTestEnvironment::get_transactions();
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    per_transaction_config cfg;
+    cfg.expiration_time(std::chrono::seconds(1));
+    cfg.custom_metadata_collection({ "default", "idontexist", "_default" });
+    try {
+        txn.run(cfg, [&](attempt_context& ctx) {
+            auto doc = ctx.get(id);
+            auto content = doc.content<nlohmann::json>();
+            content["another one"] = 1;
+            ctx.replace(doc, content);
+        });
+        FAIL() << "expected txn to throw a transaction_exception";
+    } catch (const transaction_exception& e) {
+        ASSERT_TRUE(e.type() == failure_type::EXPIRY || e.type() == failure_type::FAIL);
+    } catch (...) {
+        FAIL() << "expected transaction to throw a transaction_exception";
+    }
+    // check that doc content untouched
+    ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+}
+
+TEST(SimpleTransactions, NonExistentCollectionInPerTxnCustomMetadataCollections)
+{
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    auto txn = TransactionsTestEnvironment::get_transactions();
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    per_transaction_config cfg;
+    cfg.expiration_time(std::chrono::seconds(1));
+    cfg.custom_metadata_collection({ "default", "_default", "idontexist" });
+    try {
+        txn.run(cfg, [&](attempt_context& ctx) {
+            auto doc = ctx.get(id);
+            auto content = doc.content<nlohmann::json>();
+            content["another one"] = 1;
+            ctx.replace(doc, content);
+        });
+        FAIL() << "expected txn to throw a transaction_exception";
+    } catch (const transaction_exception& e) {
+        ASSERT_TRUE(e.type() == failure_type::EXPIRY || e.type() == failure_type::FAIL);
+    } catch (...) {
+        FAIL() << "expected transaction to throw a transaction_exception";
+    }
+    // check that doc content untouched
+    ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+}
+
+TEST(SimpleTransactions, CanUseCustomMetadataCollections)
+{
+    auto& cluster = TransactionsTestEnvironment::get_cluster();
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    transaction_config cfg;
+    cfg.custom_metadata_collection("secBucket", "_default", "_default");
+    couchbase::transactions::transactions txn(cluster, cfg);
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    txn.run([&](attempt_context& ctx) {
+        auto doc = ctx.get(id);
+        auto content = doc.content<nlohmann::json>();
+        content["another one"] = 1;
+        ctx.replace(doc, content);
+    });
+    // now add to the original content, and compare
+    c["another one"] = 1;
+    ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+}
+
+TEST(SimpleTransactions, NonExistentBucketInCustomMetadataCollections)
+{
+    auto& cluster = TransactionsTestEnvironment::get_cluster();
+    transaction_config cfg;
+    cfg.custom_metadata_collection("idontexist", "_default", "_default");
+    ASSERT_THROW(couchbase::transactions::transactions txn(cluster, cfg), std::runtime_error);
+}
+
+TEST(SimpleTransactions, NonExistentScopeInCustomMetadataCollections)
+{
+    auto& cluster = TransactionsTestEnvironment::get_cluster();
+    transaction_config cfg;
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    cfg.custom_metadata_collection("secBucket", "idontexist", "_default");
+    cfg.expiration_time(std::chrono::seconds(2));
+    couchbase::transactions::transactions txn(cluster, cfg);
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    try {
+        txn.run([&](attempt_context& ctx) {
+            auto doc = ctx.get(id);
+            auto content = doc.content<nlohmann::json>();
+            content["another one"] = 1;
+            ctx.replace(doc, content);
+        });
+        FAIL() << "expected txn to timeout";
+    } catch (const transaction_exception& e) {
+        // type could be expiry or fail, it seems.  The reason is a bit unclear.
+        ASSERT_TRUE(e.type() == failure_type::EXPIRY || e.type() == failure_type::FAIL);
+        ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+    }
+}
+
+TEST(SimpleTransactions, NonExistentCollectionInCustomMetadataCollections)
+{
+    auto& cluster = TransactionsTestEnvironment::get_cluster();
+    transaction_config cfg;
+    nlohmann::json c = nlohmann::json::parse("{\"some number\": 0}");
+    cfg.custom_metadata_collection("secBucket", "_default", "idontexist");
+    cfg.expiration_time(std::chrono::seconds(2));
+    couchbase::transactions::transactions txn(cluster, cfg);
+
+    // upsert initial doc
+    auto id = TransactionsTestEnvironment::get_document_id();
+    ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, c.dump()));
+    try {
+        txn.run([&](attempt_context& ctx) {
+            auto doc = ctx.get(id);
+            auto content = doc.content<nlohmann::json>();
+            content["another one"] = 1;
+            ctx.replace(doc, content);
+        });
+        FAIL() << "expected txn to timeout";
+    } catch (const transaction_exception& e) {
+        ASSERT_TRUE(e.type() == failure_type::EXPIRY || e.type() == failure_type::FAIL);
+        ASSERT_EQ(c, TransactionsTestEnvironment::get_doc(id).content_as<nlohmann::json>());
+    }
+}
+
 TEST(SimpleTransactions, CanGetReplaceRawStrings)
 {
     auto& cluster = TransactionsTestEnvironment::get_cluster();
@@ -241,7 +430,7 @@ TEST(SimpleTransactions, CanRollbackInsert)
         FAIL() << "expect a client_error with document_not_found, got result instead";
 
     } catch (const client_error& e) {
-        ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+        ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
     }
 }
 
@@ -463,7 +652,7 @@ TEST(SimpleQueryTransactions, CanRollbackKVInsert)
         auto doc = TransactionsTestEnvironment::get_doc(id);
         FAIL() << "expected doc to not exist";
     } catch (const client_error& e) {
-        ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+        ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
     }
 }
 
@@ -547,7 +736,7 @@ TEST(SimpleQueryTransactions, CanKVRemove)
         auto doc = TransactionsTestEnvironment::get_doc(id);
         FAIL() << "expected doc to not exist";
     } catch (const client_error& e) {
-        ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+        ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
     }
 }
 

package/deps/couchbase-transactions-cxx/tests/transactions/transaction_context_t.cpp

@@ -17,7 +17,6 @@
 #include "../../src/transactions/attempt_context_impl.hxx"
 #include "helpers.hxx"
 #include "transactions_env.h"
-#include <couchbase/errors.hxx>
 #include <couchbase/transactions.hxx>
 #include <couchbase/transactions/internal/transaction_context.hxx>
 #include <gtest/gtest.h>
@@ -319,7 +318,7 @@ TEST(SimpleTxnContext, CanDoQuery)
     ASSERT_TRUE(TransactionsTestEnvironment::upsert_doc(id, tx_content.dump()));
     auto query = fmt::format("SELECT * FROM `{}` USE KEYS '{}'", id.bucket(), id.key());
     transaction_query_options opts;
-    tx.query(query, opts, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+    tx.query(query, opts, [&](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
         EXPECT_TRUE(payload);
         EXPECT_FALSE(err);
@@ -344,16 +343,17 @@ TEST(SimpleTxnContext, CanSeeSomeQueryErrorsButNoTxnFailed)
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
     transaction_query_options opts;
-    tx.query("jkjkjl;kjlk;  jfjjffjfj", opts, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
-        // this should result in a query_exception since the query isn't parseable.
-        EXPECT_TRUE(err);
-        EXPECT_FALSE(payload);
-        if (err) {
-            barrier->set_exception(err);
-        } else {
-            barrier->set_value();
-        }
-    });
+    tx.query(
+      "jkjkjl;kjlk;  jfjjffjfj", opts, [&](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.
+          EXPECT_TRUE(err);
+          EXPECT_FALSE(payload);
+          if (err) {
+              barrier->set_exception(err);
+          } else {
+              barrier->set_value();
+          }
+      });
     try {
         f.get();
         FAIL() << "expected future to throw exception";
@@ -373,7 +373,7 @@ TEST(SimpleTxnContext, CanSetPerTxnConfig)
     auto txns = TransactionsTestEnvironment::get_transactions();
     auto id = TransactionsTestEnvironment::get_document_id();
     per_transaction_config per_txn_cfg;
-    per_txn_cfg.scan_consistency(couchbase::query_scan_consistency::not_bounded);
+    per_txn_cfg.scan_consistency(couchbase::core::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::transactions::durability_level::NONE);
     transaction_context tx(txns, per_txn_cfg);

package/deps/couchbase-transactions-cxx/tests/transactions/transactions_env.h

@@ -20,10 +20,12 @@
 #include "couchbase/transactions/internal/utils.hxx"
 #include <couchbase/transactions.hxx>
 
-#include <couchbase/cluster.hxx>
-#include <couchbase/operations.hxx>
+#include <core/cluster.hxx>
+#include <core/operations.hxx>
+#include <core/operations/management/bucket.hxx>
 #include <couchbase/support.hxx>
 
+#include <algorithm>
 #include <couchbase/internal/nlohmann/json.hpp>
 #include <cstdlib>
 #include <fstream>
@@ -44,18 +46,18 @@ namespace tx = couchbase::transactions;
 struct conn {
     asio::io_context io;
     std::list<std::thread> io_threads;
-    std::shared_ptr<couchbase::cluster> c;
+    std::shared_ptr<couchbase::core::cluster> c;
 
     conn(const nlohmann::json& conf)
       : io({})
-      , c(couchbase::cluster::create(io))
+      , c(couchbase::core::cluster::create(io))
     {
         // for tests, really chatty logs may be useful.
-        if (!couchbase::logger::is_initialized()) {
-            couchbase::logger::create_console_logger();
+        if (!couchbase::core::logger::is_initialized()) {
+            couchbase::core::logger::create_console_logger();
         }
-        couchbase::logger::set_log_levels(couchbase::logger::level::trace);
-        couchbase::transactions::set_transactions_log_level(couchbase::logger::level::trace);
+        couchbase::core::logger::set_log_levels(couchbase::core::logger::level::trace);
+        couchbase::transactions::set_transactions_log_level(couchbase::core::logger::level::trace);
         size_t num_threads = conf.contains("io_threads") ? conf["io_threads"].get<uint32_t>() : 4;
         couchbase::transactions::txn_log->trace("using {} io completion threads", num_threads);
         for (size_t i = 0; i < num_threads; i++) {
@@ -81,17 +83,17 @@ struct conn {
 
     void connect(const nlohmann::json& conf)
     {
-        couchbase::cluster_credentials auth{};
+        couchbase::core::cluster_credentials auth{};
         {
             if (auto env_val = std::getenv("COUCHBASE_CXX_CLIENT_LOG_LEVEL")) {
-                couchbase::logger::set_log_levels(couchbase::logger::level_from_str(env_val));
+                couchbase::core::logger::set_log_levels(couchbase::core::logger::level_from_str(env_val));
             }
-            auto connstr = couchbase::utils::parse_connection_string(conf["connection_string"]);
+            auto connstr = couchbase::core::utils::parse_connection_string(conf["connection_string"]);
             auth.username = "Administrator";
             auth.password = "password";
             auto barrier = std::make_shared<std::promise<std::error_code>>();
             auto f = barrier->get_future();
-            c->open(couchbase::origin(auth, connstr), [barrier](std::error_code ec) { barrier->set_value(ec); });
+            c->open(couchbase::core::origin(auth, connstr), [barrier](std::error_code ec) { barrier->set_value(ec); });
             auto rc = f.get();
             if (rc) {
                 std::cout << "ERROR opening cluster: " << rc.message() << std::endl;
@@ -110,6 +112,17 @@ struct conn {
                 exit(-1);
             }
         }
+        // now open the 'secBucket' bucket
+        {
+            auto barrier = std::make_shared<std::promise<std::error_code>>();
+            auto f = barrier->get_future();
+            c->open_bucket("secBucket", [barrier](std::error_code ec) { barrier->set_value(ec); });
+            auto rc = f.get();
+            if (rc) {
+                std::cout << "ERROR opening bucket `secBucket`: " << rc.message() << std::endl;
+                exit(-1);
+            }
+        }
 
         // do a ping
         {
@@ -125,11 +138,12 @@ struct conn {
                 std::this_thread::sleep_for(std::chrono::milliseconds(sleep_time));
                 // TEMPORARILY only ping key_value.   See CCXCBC-94 for details -- ping not returning any service
                 // except KV.
-                std::set<couchbase::service_type> services{ couchbase::service_type::key_value };
-                auto barrier = std::make_shared<std::promise<couchbase::diag::ping_result>>();
+                std::set<couchbase::core::service_type> services{ couchbase::core::service_type::key_value };
+                auto barrier = std::make_shared<std::promise<couchbase::core::diag::ping_result>>();
                 auto f = barrier->get_future();
-                c->ping(
-                  "tests_startup", "default", services, [barrier](couchbase::diag::ping_result result) { barrier->set_value(result); });
+                c->ping("tests_startup", "default", services, [barrier](couchbase::core::diag::ping_result result) {
+                    barrier->set_value(result);
+                });
                 auto result = f.get();
                 ok = true;
                 for (auto& svc : services) {
@@ -137,8 +151,8 @@ struct conn {
                         if (result.services[svc].size() > 0) {
                             ok = ok && std::all_of(result.services[svc].begin(),
                                                    result.services[svc].end(),
-                                                   [&](const couchbase::diag::endpoint_ping_info& info) {
-                                                       return (!info.error && info.state == couchbase::diag::ping_state::ok);
+                                                   [&](const couchbase::core::diag::endpoint_ping_info& info) {
+                                                       return (!info.error && info.state == couchbase::core::diag::ping_state::ok);
                                                    });
                         } else {
                             ok = false;
@@ -186,14 +200,14 @@ class TransactionsTestEnvironment : public ::testing::Environment
         return conf;
     }
 
-    static bool upsert_doc(const couchbase::document_id& id, const std::string& content)
+    static bool upsert_doc(const couchbase::core::document_id& id, const std::string& content)
     {
         auto& c = get_cluster();
-        couchbase::operations::upsert_request req{ id };
-        req.value = content;
+        couchbase::core::operations::upsert_request req{ id };
+        req.value = couchbase::core::utils::to_binary(content);
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
-        c.execute(req, [barrier](couchbase::operations::upsert_response resp) { barrier->set_value(resp.ctx.ec); });
+        c.execute(req, [barrier](couchbase::core::operations::upsert_response resp) { barrier->set_value(resp.ctx.ec()); });
         auto ec = f.get();
         if (ec) {
             spdlog::error("upsert doc failed with {}", ec.message());
@@ -201,14 +215,14 @@ class TransactionsTestEnvironment : public ::testing::Environment
         return !ec;
     }
 
-    static bool insert_doc(const couchbase::document_id& id, const std::string& content)
+    static bool insert_doc(const couchbase::core::document_id& id, const std::string& content)
     {
         auto& c = get_cluster();
-        couchbase::operations::insert_request req{ id };
-        req.value = content;
+        couchbase::core::operations::insert_request req{ id };
+        req.value = couchbase::core::utils::to_binary(content);
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
-        c.execute(req, [barrier](couchbase::operations::insert_response resp) { barrier->set_value(resp.ctx.ec); });
+        c.execute(req, [barrier](couchbase::core::operations::insert_response resp) { barrier->set_value(resp.ctx.ec()); });
         auto ec = f.get();
         if (ec) {
             spdlog::error("insert doc failed with {}", ec.message());
@@ -216,29 +230,30 @@ class TransactionsTestEnvironment : public ::testing::Environment
         return !ec;
     }
 
-    static tx::result get_doc(const couchbase::document_id& id)
+    static tx::result get_doc(const couchbase::core::document_id& id)
     {
         auto& c = get_cluster();
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto barrier = std::make_shared<std::promise<tx::result>>();
         auto f = barrier->get_future();
-        c.execute(req, [barrier](couchbase::operations::get_response resp) { barrier->set_value(tx::result::create_from_response(resp)); });
+        c.execute(
+          req, [barrier](couchbase::core::operations::get_response resp) { barrier->set_value(tx::result::create_from_response(resp)); });
         return tx::wrap_operation_future(f);
     }
 
-    static couchbase::cluster& get_cluster()
+    static couchbase::core::cluster& get_cluster()
     {
         static conn connection(get_conf());
         return *connection.c;
     }
 
-    static couchbase::document_id get_document_id(const std::string& id = {})
+    static couchbase::core::document_id get_document_id(const std::string& id = {})
     {
         std::string key = (id.empty() ? couchbase::transactions::uid_generator::next() : id);
         return { "default", "_default", "_default", key };
     }
 
-    static couchbase::transactions::transactions get_transactions(couchbase::cluster& c = get_cluster(),
+    static couchbase::transactions::transactions get_transactions(couchbase::core::cluster& c = get_cluster(),
                                                                   bool cleanup_client_attempts = false,
                                                                   bool cleanup_lost_txns = false)
     {