couchbase 4.2.3 → 4.2.4

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

@@ -63,8 +63,13 @@ TEST_CASE("integration: get any replica", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
-    if (integration.number_of_replicas() == 0 && integration.number_of_nodes() <= integration.number_of_replicas()) {
-        return;
+    if (integration.number_of_replicas() == 0) {
+        SKIP("bucket has zero replicas");
+    }
+    if (integration.number_of_nodes() <= integration.number_of_replicas()) {
+        SKIP(fmt::format("number of nodes ({}) is less or equal to number of replicas ({})",
+                         integration.number_of_nodes(),
+                         integration.number_of_replicas()));
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -95,8 +100,12 @@ TEST_CASE("integration: get all replicas", "[integration]")
     test::utils::integration_test_guard integration;
 
     auto number_of_replicas = integration.number_of_replicas();
-    if (number_of_replicas == 0 && integration.number_of_nodes() <= number_of_replicas) {
-        return;
+    if (number_of_replicas == 0) {
+        SKIP("bucket has zero replicas");
+    }
+    if (integration.number_of_nodes() <= number_of_replicas) {
+        SKIP(fmt::format(
+          "number of nodes ({}) is less or equal to number of replicas ({})", integration.number_of_nodes(), number_of_replicas));
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -109,10 +118,16 @@ TEST_CASE("integration: get all replicas", "[integration]")
         couchbase::core::document_id id{ integration.ctx.bucket, scope_name, collection_name, key };
 
         couchbase::core::operations::insert_request req{ id, basic_doc_json };
+        req.durability_level = couchbase::durability_level::majority_and_persist_to_active;
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
+    if (integration.cluster_version().is_mock()) {
+        // GOCAVES does not implement syncDurability. See https://github.com/couchbaselabs/gocaves/issues/109
+        std::this_thread::sleep_for(std::chrono::seconds{ 1 });
+    }
+
     {
         auto collection =
           couchbase::cluster(integration.cluster).bucket(integration.ctx.bucket).scope(scope_name).collection(collection_name);
@@ -128,8 +143,13 @@ TEST_CASE("integration: get all replicas with missing key", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
-    if (integration.number_of_replicas() == 0 && integration.number_of_nodes() <= integration.number_of_replicas()) {
-        return;
+    if (integration.number_of_replicas() == 0) {
+        SKIP("bucket has zero replicas");
+    }
+    if (integration.number_of_nodes() <= integration.number_of_replicas()) {
+        SKIP(fmt::format("number of nodes ({}) is less or equal to number of replicas ({})",
+                         integration.number_of_nodes(),
+                         integration.number_of_replicas()));
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -152,7 +172,9 @@ TEST_CASE("integration: get any replica with missing key", "[integration]")
     test::utils::integration_test_guard integration;
 
     if (integration.number_of_nodes() <= integration.number_of_replicas()) {
-        return;
+        SKIP(fmt::format("number of nodes ({}) is less or equal to number of replicas ({})",
+                         integration.number_of_nodes(),
+                         integration.number_of_replicas()));
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -173,8 +195,13 @@ TEST_CASE("integration: get any replica low-level version", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
-    if (integration.number_of_replicas() == 0 && integration.number_of_nodes() <= integration.number_of_replicas()) {
-        return;
+    if (integration.number_of_replicas() == 0) {
+        SKIP("bucket has zero replicas");
+    }
+    if (integration.number_of_nodes() <= integration.number_of_replicas()) {
+        SKIP(fmt::format("number of nodes ({}) is less or equal to number of replicas ({})",
+                         integration.number_of_nodes(),
+                         integration.number_of_replicas()));
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -204,8 +231,12 @@ TEST_CASE("integration: get all replicas low-level version", "[integration]")
     test::utils::integration_test_guard integration;
 
     auto number_of_replicas = integration.number_of_replicas();
-    if (number_of_replicas == 0 && integration.number_of_nodes() <= integration.number_of_replicas()) {
-        return;
+    if (number_of_replicas == 0) {
+        SKIP("bucket has zero replicas");
+    }
+    if (integration.number_of_nodes() <= number_of_replicas) {
+        SKIP(fmt::format(
+          "number of nodes ({}) is less or equal to number of replicas ({})", integration.number_of_nodes(), number_of_replicas));
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -217,10 +248,16 @@ TEST_CASE("integration: get all replicas low-level version", "[integration]")
             { "b", 2.0 },
         };
         couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::json::generate_binary(value) };
+        req.durability_level = couchbase::durability_level::majority_and_persist_to_active;
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
+    if (integration.cluster_version().is_mock()) {
+        // GOCAVES does not implement syncDurability. See https://github.com/couchbaselabs/gocaves/issues/109
+        std::this_thread::sleep_for(std::chrono::seconds{ 1 });
+    }
+
     {
         couchbase::core::operations::get_all_replicas_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);

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

@@ -23,12 +23,18 @@
 #include "core/operations/management/search_index_drop.hxx"
 #include "core/operations/management/search_index_upsert.hxx"
 
+#include <couchbase/query_string_query.hxx>
+
 using Catch::Matchers::StartsWith;
 
 TEST_CASE("integration: search query")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_search()) {
+        SKIP("cluster does not support search");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     {
@@ -350,6 +356,14 @@ TEST_CASE("integration: search query consistency", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (integration.ctx.deployment == test::utils::deployment_type::elixir) {
+        SKIP("elixir deployment is incompatible with parts of this test");
+    }
+
+    if (!integration.cluster_version().supports_search()) {
+        SKIP("cluster does not support search");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     const std::string params =
@@ -476,8 +490,12 @@ TEST_CASE("integration: search query collections")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_search()) {
+        SKIP("cluster does not support search");
+    }
+
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);

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

@@ -197,6 +197,10 @@ TEST_CASE("integration: subdoc get & exists", "[integration]")
 
         SECTION("non json get")
         {
+            if (integration.cluster_version().is_mock()) {
+                SKIP("GOCAVES does not handle subdocument operations for non-JSON documents. See "
+                     "https://github.com/couchbaselabs/gocaves/issues/103");
+            }
             assert_single_lookup_error(integration,
                                        non_json_id,
                                        couchbase::lookup_in_specs::get("non-exist"),
@@ -206,6 +210,10 @@ TEST_CASE("integration: subdoc get & exists", "[integration]")
 
         SECTION("non json exists")
         {
+            if (integration.cluster_version().is_mock()) {
+                SKIP("GOCAVES does not handle subdocument operations for non-JSON documents. See "
+                     "https://github.com/couchbaselabs/gocaves/issues/103");
+            }
             assert_single_lookup_error(integration,
                                        non_json_id,
                                        couchbase::lookup_in_specs::exists("non-exist"),
@@ -218,11 +226,19 @@ TEST_CASE("integration: subdoc get & exists", "[integration]")
     {
         std::vector<std::string> invalid_paths = { "invalid..path", "invalid[-2]" };
         for (const auto& path : invalid_paths) {
-            assert_single_lookup_error(integration,
-                                       id,
-                                       couchbase::lookup_in_specs::get(path),
-                                       couchbase::key_value_status_code::subdoc_path_invalid,
-                                       couchbase::errc::key_value::path_invalid);
+            if (integration.cluster_version().is_mock()) {
+                assert_single_lookup_error(integration,
+                                           id,
+                                           couchbase::lookup_in_specs::get(path),
+                                           couchbase::key_value_status_code::subdoc_path_not_found,
+                                           couchbase::errc::key_value::path_not_found);
+            } else {
+                assert_single_lookup_error(integration,
+                                           id,
+                                           couchbase::lookup_in_specs::get(path),
+                                           couchbase::key_value_status_code::subdoc_path_invalid,
+                                           couchbase::errc::key_value::path_invalid);
+            }
         }
     }
 
@@ -317,6 +333,10 @@ TEST_CASE("integration: subdoc store", "[integration]")
 
     SECTION("non json")
     {
+        if (integration.cluster_version().is_mock()) {
+            SKIP("GOCAVES does not handle subdocument operations for non-JSON documents. See "
+                 "https://github.com/couchbaselabs/gocaves/issues/103");
+        }
         std::string path{ "dict" };
         auto value = couchbase::core::utils::to_binary("non-json");
         couchbase::core::operations::mutate_in_request req{ id };
@@ -411,6 +431,11 @@ TEST_CASE("integration: subdoc mutate in store semantics", "[integration]")
 TEST_CASE("integration: subdoc unique", "[integration]")
 {
     test::utils::integration_test_guard integration;
+
+    if (integration.cluster_version().is_mock()) {
+        SKIP("GOCAVES does not support subdocument create_path feature. See https://github.com/couchbaselabs/gocaves/issues/17");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
@@ -453,7 +478,6 @@ TEST_CASE("integration: subdoc unique", "[integration]")
           couchbase::mutate_in_specs{ couchbase::mutate_in_specs::array_append("a", tao::json::empty_object).create_path() }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
         assert_single_mutate_success(resp, "a");
-        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::get("a[-1]"), "{}");
     }
 
     {
@@ -472,7 +496,10 @@ TEST_CASE("integration: subdoc counter", "[integration]")
     couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
     {
-        auto value_json = couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
+        auto value_json =
+          integration.cluster_version().is_mock() // kv_engine creates counters automatically
+            ? couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]],"counter":0})")
+            : couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
         couchbase::core::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec());
@@ -497,6 +524,9 @@ TEST_CASE("integration: subdoc counter", "[integration]")
 
     SECTION("max value")
     {
+        if (integration.cluster_version().is_mock()) {
+            SKIP("GOCAVES incorrectly handles limits for subdoc counters. See https://github.com/couchbaselabs/gocaves/issues/104");
+        }
         {
             int64_t max_value = std::numeric_limits<int64_t>::max();
             couchbase::core::operations::mutate_in_request req{ id };
@@ -516,6 +546,9 @@ TEST_CASE("integration: subdoc counter", "[integration]")
 
     SECTION("invalid delta")
     {
+        if (integration.cluster_version().is_mock()) {
+            SKIP("GOCAVES incorrectly handles zero delta for subdoc counters. See https://github.com/couchbaselabs/gocaves/issues/105");
+        }
         couchbase::core::operations::mutate_in_request req{ id };
         req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::increment("counter", 0) }.specs();
         auto resp = test::utils::execute(integration.cluster, req);
@@ -525,6 +558,9 @@ TEST_CASE("integration: subdoc counter", "[integration]")
 
     SECTION("increase number already too big")
     {
+        if (integration.cluster_version().is_mock()) {
+            SKIP("GOCAVES incorrectly handles big values for subdoc counters. See https://github.com/couchbaselabs/gocaves/issues/106");
+        }
         {
             auto big_value = R"({"counter":)" + std::to_string(std::numeric_limits<int64_t>::max()) + "999999999999999999999999999999}";
             auto value_json = couchbase::core::utils::to_binary(big_value);
@@ -621,7 +657,11 @@ TEST_CASE("integration: subdoc multi lookup", "[integration]")
           }
             .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec() == couchbase::errc::common::invalid_argument);
+        if (integration.cluster_version().is_mock()) {
+            REQUIRE(resp.ctx.ec() == couchbase::errc::common::unsupported_operation);
+        } else {
+            REQUIRE(resp.ctx.ec() == couchbase::errc::common::invalid_argument);
+        }
     }
 
     SECTION("missing key")
@@ -647,7 +687,10 @@ TEST_CASE("integration: subdoc multi mutation", "[integration]")
     couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 
     {
-        auto value_json = couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
+        auto value_json =
+          integration.cluster_version().is_mock() // kv_engine creates counters automatically
+            ? couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]],"counter":0})")
+            : couchbase::core::utils::to_binary(R"({"dictkey":"dictval","array":[1,2,3,4,[10,20,30,[100,200,300]]]})");
         couchbase::core::operations::insert_request req{ id, value_json };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec());
@@ -676,6 +719,9 @@ TEST_CASE("integration: subdoc multi mutation", "[integration]")
 
     SECTION("replace with errors")
     {
+        if (integration.cluster_version().is_mock()) {
+            SKIP("GOCAVES incorrectly uses error indexes for subdoc mutations. See https://github.com/couchbaselabs/gocaves/issues/107");
+        }
         couchbase::core::operations::mutate_in_request req{ id };
         req.specs =
           couchbase::mutate_in_specs{
@@ -695,6 +741,11 @@ TEST_CASE("integration: subdoc multi mutation", "[integration]")
 TEST_CASE("integration: subdoc expiry")
 {
     test::utils::integration_test_guard integration;
+
+    if (integration.cluster_version().is_mock()) {
+        SKIP("GOCAVES does not support subdoc mutations with expiry. See https://github.com/couchbaselabs/gocaves/issues/85");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("subdoc") };
 

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

@@ -249,6 +249,9 @@ TEST_CASE("integration: enable external tracer", "[integration]")
     {
         SECTION("query")
         {
+            if (!guard.cluster_version().supports_query()) {
+                SKIP("cluster does not support query");
+            }
             tracer->reset();
             couchbase::core::operations::query_request req{ R"(SELECT "ruby rules" AS greeting)" };
             req.parent_span = parent_span;

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

@@ -431,6 +431,10 @@ TEST_CASE("integration: subdoc with public API", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (integration.cluster_version().is_mock()) {
+        SKIP("GOCAVES incorrectly uses error indexes for subdoc mutations. See https://github.com/couchbaselabs/gocaves/issues/107");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     auto collection = couchbase::cluster(integration.cluster)

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

@@ -18,14 +18,18 @@
 #include "test_helper_integration.hxx"
 
 #include <couchbase/cluster.hxx>
+#include <couchbase/fmt/cas.hxx>
 #include <couchbase/transactions/attempt_context.hxx>
+
 #include <tao/json.hpp>
 
 namespace blocking_txn
 {
 //! [blocking-txn]
 #include <couchbase/cluster.hxx>
+#include <couchbase/fmt/cas.hxx>
 #include <couchbase/transactions/attempt_context.hxx>
+
 #include <tao/json.hpp>
 
 int
@@ -38,9 +42,10 @@ main(int argc, const char* argv[])
 
     int retval = 0;
 
-    std::string connection_string{ argv[1] };
-    std::string username{ argv[2] };
-    std::string password{ argv[3] };
+    const std::string connection_string{ argv[1] };
+    const std::string username{ argv[2] };
+    const std::string password{ argv[3] };
+
     // run IO context on separate thread
     asio::io_context io;
     auto guard = asio::make_work_guard(io);
@@ -51,106 +56,116 @@ main(int argc, const char* argv[])
     // For example, optimize timeouts for WAN
     options.apply_profile("wan_development");
 
+    // [1] connect to cluster using the given connection string and the options
     auto [cluster, ec] = couchbase::cluster::connect(io, connection_string, options).get();
     if (ec) {
         fmt::print("unable to connect to the cluster: {}\n", ec.message());
         return 1;
     }
 
-    auto coll = cluster.bucket("default").default_collection();
-    auto id = "my-doc";
-    auto id2 = "my_doc_2";
-    auto id3 = "my_doc_3";
-    ::tao::json::value content = { { "some", "content" } };
-
-    // upsert all 3...
-    auto [upsert_err, upsert_res] = coll.upsert(id, content).get();
-    if (upsert_err.ec()) {
-        fmt::print("upsert failed before starting transaction");
-        return 1;
-    }
-    auto [upsert_err2, upsert_res2] = coll.upsert(id2, content).get();
-    if (upsert_err2.ec()) {
-        fmt::print("upsert failed before starting transaction");
-        return 1;
-    }
-    auto [upsert_err3, upsert_res3] = coll.upsert(id3, content).get();
-    if (upsert_err3.ec()) {
-        fmt::print("upsert failed before starting transaction");
-        return 1;
+    // [2] persist three documents to the default collection of bucket "default"
+    auto collection = cluster.bucket("default").default_collection();
+    constexpr auto id_1 = "my-doc_1";
+    constexpr auto id_2 = "my_doc_2";
+    constexpr auto id_3 = "my_doc_3";
+    const tao::json::value content = { { "some", "content" } };
+
+    for (const auto& id : { id_1, id_2, id_3 }) {
+        if (auto [ctx, res] = collection.upsert(id, content).get(); ctx.ec()) {
+            fmt::print(stderr, "upsert \"{}\" failed before starting transaction: {}\n", id, ctx.ec().message());
+            return 1;
+        }
     }
 
-    //! [simple-blocking-txn]
-    auto [e, txn_res] = cluster.transactions()->run([&](couchbase::transactions::attempt_context& ctx) {
-        // get document
-        auto [get_err, doc] = ctx.get(coll, id);
-        if (get_err.ec()) {
-            fmt::print("error getting doc {}: {}", id, get_err.ec().message());
-            // don't continue the txn logic.
-            return;
+    { // [3] blocking transaction
+        //! [simple-blocking-txn]
+        auto [tx_err, tx_res] = cluster.transactions()->run(
+          // [3.1] closure argument to run() method encapsulates logic, that has to be run in transaction
+          [&](couchbase::transactions::attempt_context& ctx) {
+              // [3.2] get document
+              auto [err_ctx, doc] = ctx.get(collection, id_1);
+              if (err_ctx.ec()) {
+                  fmt::print(stderr, "failed to get document \"{}\": {}\n", id_1, err_ctx.ec().message());
+                  // [3.3] don't continue the transaction logic
+                  return;
+              }
+              // [3.4] replace document's content
+              ctx.replace(doc, ::tao::json::value{ { "some", "other content" } });
+          });
+        // [3.5] check the overall status of the transaction
+        if (tx_err.ec()) {
+            fmt::print(stderr, "error in transaction {}, cause: {}\n", tx_err.ec().message(), tx_err.cause().message());
+            retval = 1;
+        } else {
+            fmt::print("transaction {} completed successfully", tx_res.transaction_id);
         }
-        // replace document content
-        ctx.replace(doc, ::tao::json::value{ { "some", "other content" } });
-    });
-    if (e.ec()) {
-        fmt::print("error in transaction {}, {}", e.ec().message(), e.cause().message());
-        retval = 1;
-    } else {
-        fmt::print("transaction {} completed successfully", txn_res.transaction_id);
+        //! [simple-blocking-txn]
     }
-    //! [simple-blocking-txn]
-
-    //! [simple-async-txn]
-    auto barrier = std::make_shared<std::promise<std::error_code>>();
-    auto f = barrier->get_future();
-    cluster.transactions()->run(
-      [&](couchbase::transactions::async_attempt_context& ctx) {
-          ctx.get(coll, id, [&](auto get_err, auto doc) {
-              if (get_err.ec()) {
-                  fmt::print("error getting doc {}: {}", id, get_err.ec().message());
-              } else {
-                  ctx.replace(doc, ::tao::json::value{ { "some", "other async content" } }, [&](auto replace_err, auto) {
-                      if (replace_err.ec()) {
-                          fmt::print("error replacing content in doc {}: {}", id, replace_err.ec().message());
+
+    { // [4] asynchronous transaction
+        //! [simple-async-txn]
+        // [4.1] create promise to retrieve result from the transaction
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        cluster.transactions()->run(
+          // [4.2] closure argument to run() method encapsulates logic, that has to be run in transaction
+          [&](couchbase::transactions::async_attempt_context& ctx) {
+              // [4.3] get document
+              ctx.get(collection, id_1, [&](auto err_ctx_1, auto doc) {
+                  if (err_ctx_1.ec()) {
+                      fmt::print(stderr, "failed to get document \"{}\": {}\n", id_1, err_ctx_1.ec().message());
+                      return;
+                  }
+                  // [4.4] replace document's content
+                  ctx.replace(doc, ::tao::json::value{ { "some", "other async content" } }, [&](auto err_ctx_2, auto res) {
+                      if (err_ctx_2.ec()) {
+                          fmt::print(stderr, "error replacing content in doc {}: {}\n", id_1, err_ctx_2.ec().message());
+                      } else {
+                          fmt::print("successfully replaced: {}, cas={}\n", id_1, res.cas());
                       }
                   });
-              }
-          });
-          ctx.get(coll, id2, [&](auto get_err, auto doc) {
-              if (get_err.ec()) {
-                  fmt::print("error getting doc {}: {}", id2, get_err.ec().message());
-              } else {
-                  ctx.replace(doc, ::tao::json::value{ { "some", "other async content" } }, [&](auto replace_err, auto) {
-                      if (replace_err.ec()) {
-                          fmt::print("error replacing content in doc {}: {}", id, replace_err.ec().message());
+              });
+              ctx.get(collection, id_2, [&](auto err_ctx_1, auto doc) {
+                  if (err_ctx_1.ec()) {
+                      fmt::print("error getting doc {}: {}", id_2, err_ctx_1.ec().message());
+                      return;
+                  }
+                  ctx.replace(doc, ::tao::json::value{ { "some", "other async content" } }, [&](auto err_ctx_2, auto res) {
+                      if (err_ctx_2.ec()) {
+                          fmt::print(stderr, "error replacing content in doc {}: {}\n", id_2, err_ctx_2.ec().message());
+                      } else {
+                          fmt::print("successfully replaced: {}, cas={}\n", id_2, res.cas());
                       }
                   });
-              }
-          });
-          ctx.get(coll, id3, [&](auto get_err, auto doc) {
-              if (get_err.ec()) {
-                  fmt::print("error getting doc {}: {}", id, get_err.ec().message());
-              } else {
-                  ctx.replace(doc, ::tao::json::value{ { "some", "other async content" } }, [&](auto replace_err, auto) {
-                      if (replace_err.ec()) {
-                          fmt::print("error replacing content in doc {}: {}", id3, replace_err.ec().message());
+              });
+              ctx.get(collection, id_3, [&](auto err_ctx_1, auto doc) {
+                  if (err_ctx_1.ec()) {
+                      fmt::print("error getting doc {}: {}", id_3, err_ctx_1.ec().message());
+                      return;
+                  }
+                  ctx.replace(doc, ::tao::json::value{ { "some", "other async content" } }, [&](auto err_ctx_2, auto res) {
+                      if (err_ctx_2.ec()) {
+                          fmt::print(stderr, "error replacing content in doc {}: {}\n", id_3, err_ctx_2.ec().message());
+                      } else {
+                          fmt::print("successfully replaced: {}, cas={}\n", id_3, res.cas());
                       }
                   });
+              });
+          },
+          // [4.5], second closure represents transaction completion logic
+          [barrier](auto tx_err, auto tx_res) {
+              if (tx_err.ec()) {
+                  fmt::print(stderr, "error in async transaction {}, {}\n", tx_res.transaction_id, tx_err.ec().message());
               }
+              barrier->set_value(tx_err.ec());
           });
-      },
-      [barrier](auto tx_err, auto tx_result) {
-          if (tx_err.ec()) {
-              fmt::print("error in async transaction {}, {}", tx_result.transaction_id, tx_err.ec().message());
-          }
-          barrier->set_value(tx_err.ec());
-      });
-    if (auto async_err = f.get()) {
-        retval = 1;
+        if (auto async_err = f.get()) {
+            retval = 1;
+        }
+        //! [simple-async-txn]
     }
-    //! [simple-async-txn]
 
-    // close cluster connection
+    // [5], close cluster connection
     cluster.close();
     guard.reset();
 
@@ -161,11 +176,11 @@ main(int argc, const char* argv[])
 //! [blocking-txn]
 } // namespace blocking_txn
 
-TEST_CASE("example: start using", "[integration]")
+TEST_CASE("example: basic transaction", "[integration]")
 {
     test::utils::integration_test_guard integration;
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
 
     const auto env = test::utils::test_context::load_from_environment();

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

@@ -416,4 +416,33 @@ TEST_CASE("unit: connection string", "[unit]")
         CHECK(couchbase::core::utils::parse_connection_string("couchbase://2001:db8:85a3:8d3:1319:8a2e:370:7348").error.value() ==
               R"(failed to parse connection string (column: 18, trailer: "db8:85a3:8d3:1319:8a2e:370:7348"))");
     }
+
+    SECTION("parsing warnings")
+    {
+        auto spec = couchbase::core::utils::parse_connection_string("couchbase://127.0.0.1?kv_timeout=42&foo=bar");
+        CHECK(spec.warnings == std::vector<std::string>{
+                                 R"(unknown parameter "foo" in connection string (value "bar"))",
+                               });
+
+        spec = couchbase::core::utils::parse_connection_string("couchbase://127.0.0.1?enable_dns_srv=maybe&ip_protocol=yes");
+        CHECK(spec.warnings ==
+              std::vector<std::string>{
+                R"(unable to parse "enable_dns_srv" parameter in connection string (value "maybe" cannot be interpreted as a boolean))",
+                R"(unable to parse "ip_protocol" parameter in connection string (value "yes" is not a valid IP protocol preference))",
+              });
+
+        spec = couchbase::core::utils::parse_connection_string("couchbase://localhost:8091=http;127.0.0.1=mcd/default?enable_dns_srv=true");
+        CHECK(
+          spec.warnings ==
+          std::vector<std::string>{
+            R"(parameter "enable_dns_srv" requires single entry in bootstrap nodes list of the connection string, ignoring (value "true"))",
+          });
+
+        spec = couchbase::core::utils::parse_connection_string(
+          "couchbase://localhost?query_timeout=10000&kv_timeout=true&management_timeout=11000");
+        std::string warning_prefix = R"(unable to parse "kv_timeout" parameter in connection string (value "true" is not a number))";
+        CHECK(spec.warnings.at(0).substr(0, warning_prefix.size()) == warning_prefix);
+        CHECK(spec.options.query_timeout == std::chrono::milliseconds(10000));
+        CHECK(spec.options.management_timeout == std::chrono::milliseconds(11000));
+    }
 }