couchbase 4.2.2 → 4.2.4

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

@@ -19,10 +19,22 @@
 #include "core/transactions/internal/exceptions_internal.hxx"
 #include "core/transactions/internal/utils.hxx"
 
+#include <core/transactions/transaction_get_result.hxx>
+#include <couchbase/transactions/transaction_get_result.hxx>
+
 #include <iostream>
 #include <limits>
 #include <thread>
 
+#if defined(__GNUC__)
+#if __GNUC__ <= 10
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+#if __GNUC__ < 9
+#pragma GCC diagnostic ignored "-Wuseless-cast"
+#endif
+#endif
+
 using namespace couchbase::core::transactions;
 using namespace std;
 
@@ -212,3 +224,104 @@ TEST_CASE("retryable op: can have constant delay", "[unit]")
         REQUIRE(state.timings.size() == 10);
     }
 }
+
+TEST_CASE("transaction_get_result: can convert core transaction_get_result to public, and visa-versa", "[unit]")
+{
+    const tao::json::value content{ { "some_number", 0 } };
+    const auto binary_content = couchbase::core::utils::json::generate_binary(content);
+    const std::string bucket = "bucket";
+    const std::string scope = "scope";
+    const std::string collection = "collection";
+    const std::string key = "key";
+    const couchbase::cas cas(100ULL);
+    const auto fwd_compat = tao::json::value::array({ "xxx", "yyy" });
+    const couchbase::core::transactions::transaction_links links("atr_id",
+                                                                 "atr_bucket",
+                                                                 "atr_scope",
+                                                                 "atr_collection",
+                                                                 "txn_id",
+                                                                 "attempt_id",
+                                                                 "op_id",
+                                                                 binary_content,
+                                                                 "cas_pre_txn",
+                                                                 "rev_pre_txn",
+                                                                 0,
+                                                                 "crc",
+                                                                 "op",
+                                                                 fwd_compat,
+                                                                 false);
+    const couchbase::core::transactions::document_metadata metadata("cas", "revid", 0, "crc32");
+
+    SECTION("core->public")
+    {
+        couchbase::core::transactions::transaction_get_result core_result(
+          { bucket, scope, collection, key }, binary_content, cas.value(), links, metadata);
+        auto public_result = core_result.to_public_result();
+        REQUIRE(public_result.collection() == collection);
+        REQUIRE(public_result.bucket() == bucket);
+        REQUIRE(public_result.scope() == scope);
+        REQUIRE(public_result.cas() == cas);
+        REQUIRE(public_result.key() == key);
+        REQUIRE(public_result.content() == binary_content);
+        REQUIRE(public_result.content<tao::json::value>() == content);
+        REQUIRE(core_result.collection() == collection);
+        REQUIRE(core_result.bucket() == bucket);
+        REQUIRE(core_result.scope() == scope);
+        REQUIRE(core_result.cas() == cas);
+        REQUIRE(core_result.key() == key);
+        // the content is _moved_ when creating the public_result, so lets not touch the
+        // core_result.content() since it can be anything.  The std::vector is _valid_, so we
+        // can manipulate it, but the contents are not guaranteed.
+    }
+    SECTION("core->public->core")
+    {
+        couchbase::core::transactions::transaction_get_result core_result(
+          { bucket, scope, collection, key }, binary_content, cas.value(), links, metadata);
+        auto public_result = core_result.to_public_result();
+        couchbase::core::transactions::transaction_get_result final_core_result(public_result);
+        REQUIRE(core_result.collection() == final_core_result.collection());
+        REQUIRE(core_result.bucket() == final_core_result.bucket());
+        REQUIRE(core_result.scope() == final_core_result.scope());
+        REQUIRE(core_result.cas() == final_core_result.cas());
+        REQUIRE(final_core_result.content() == binary_content);
+        REQUIRE(core_result.key() == final_core_result.key());
+        REQUIRE(final_core_result.cas() == cas);
+        REQUIRE(final_core_result.bucket() == bucket);
+        REQUIRE(final_core_result.scope() == scope);
+        REQUIRE(final_core_result.collection() == collection);
+        REQUIRE(final_core_result.key() == key);
+        REQUIRE(final_core_result.content() == binary_content);
+        REQUIRE(final_core_result.links().staged_operation_id() == links.staged_operation_id());
+        REQUIRE(final_core_result.links().staged_attempt_id() == links.staged_attempt_id());
+        REQUIRE(final_core_result.links().crc32_of_staging() == links.crc32_of_staging());
+        REQUIRE(final_core_result.links().atr_collection_name() == links.atr_collection_name());
+        REQUIRE(final_core_result.links().atr_scope_name() == links.atr_scope_name());
+        REQUIRE(final_core_result.links().atr_bucket_name() == links.atr_bucket_name());
+        REQUIRE(final_core_result.links().is_deleted() == links.is_deleted());
+        REQUIRE(final_core_result.links().forward_compat() == links.forward_compat());
+        REQUIRE(final_core_result.links().atr_id() == links.atr_id());
+        REQUIRE(final_core_result.links().cas_pre_txn() == links.cas_pre_txn());
+        REQUIRE(final_core_result.links().exptime_pre_txn() == links.exptime_pre_txn());
+        REQUIRE(final_core_result.links().op() == links.op());
+        REQUIRE(final_core_result.links().revid_pre_txn() == links.revid_pre_txn());
+        REQUIRE(final_core_result.links().staged_content() == links.staged_content());
+        REQUIRE(final_core_result.links().staged_transaction_id() == links.staged_transaction_id());
+        REQUIRE(final_core_result.metadata()->cas() == metadata.cas());
+        REQUIRE(final_core_result.metadata()->crc32() == metadata.crc32());
+        REQUIRE(final_core_result.metadata()->exptime() == metadata.exptime());
+        REQUIRE(final_core_result.metadata()->revid() == metadata.revid());
+    }
+    SECTION("default constructed core->public")
+    {
+        couchbase::core::transactions::transaction_get_result core_result{};
+        auto final_public_result = core_result.to_public_result();
+        REQUIRE(final_public_result.cas().empty());
+    }
+    SECTION("default constructed public->core->public")
+    {
+        couchbase::transactions::transaction_get_result public_res;
+        couchbase::core::transactions::transaction_get_result core_res(public_res);
+        auto final_public_res = core_res.to_public_result();
+        REQUIRE(final_public_res.cas().empty());
+    }
+}

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

@@ -17,6 +17,10 @@
 
 #include "test_helper.hxx"
 
+#include <catch2/matchers/catch_matchers.hpp>
+#include <catch2/matchers/catch_matchers_exception.hpp>
+#include <catch2/matchers/catch_matchers_string.hpp>
+
 #include "core/meta/version.hxx"
 #include "core/platform/base64.h"
 #include "core/utils/join_strings.hxx"
@@ -32,14 +36,14 @@
 
 TEST_CASE("unit: transformer to deduplicate JSON keys", "[unit]")
 {
-    using Catch::Contains;
+    using Catch::Matchers::ContainsSubstring;
 
     std::string input{ R"({"answer":"wrong","answer":42})" };
 
-    CHECK_THROWS_WITH(tao::json::from_string(input), Contains("duplicate JSON object key \"answer\""));
+    CHECK_THROWS_WITH(tao::json::from_string(input), ContainsSubstring("duplicate JSON object key \"answer\""));
 
     auto result = couchbase::core::utils::json::parse(input);
-    INFO(couchbase::core::utils::json::generate(result))
+    INFO(couchbase::core::utils::json::generate(result));
     CHECK(result.is_object());
     CHECK(result.find("answer") != nullptr);
     CHECK(result["answer"].is_integer());
@@ -96,7 +100,7 @@ TEST_CASE("unit: user_agent string", "[unit]")
 
     auto simple_user_agent = couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE");
     REQUIRE(simple_user_agent == fmt::format(R"({{"a":"{}","i":"0xDEADBEEF/0xCAFEBEBE"}})", core_version));
-    REQUIRE(simple_user_agent.size() == 66);
+    REQUIRE(simple_user_agent.size() == 53 + os_version.size());
 
     REQUIRE(couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", "couchnode/1.2.3; openssl/1.1.1l") ==
             fmt::format(R"({{"a":"{};couchnode/1.2.3; openssl/1.1.1l","i":"0xDEADBEEF/0xCAFEBEBE"}})", core_version));

package/deps/couchbase-cxx-client/test/utils/CMakeLists.txt

@@ -6,15 +6,19 @@ add_library(
   logger.cxx
   server_version.cxx
   test_context.cxx
-  uniq_id.cxx
+  test_data.cxx
   wait_until.cxx)
 set_target_properties(test_utils PROPERTIES POSITION_INDEPENDENT_CODE ON)
-target_link_libraries(test_utils PRIVATE project_options project_warnings OpenSSL::SSL fmt::fmt spdlog::spdlog)
+target_link_libraries(test_utils PRIVATE project_options project_warnings fmt::fmt spdlog::spdlog)
 target_include_directories(test_utils PRIVATE ${PROJECT_SOURCE_DIR})
-if (MSVC)
-    target_compile_definitions(test_utils PRIVATE _CRT_SECURE_NO_WARNINGS)
-    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-        target_compile_options(test_utils PUBLIC -Wno-deprecated-declarations)
-    endif ()
-endif ()
-
+if (TARGET PkgConfig::PKG_CONFIG_OPENSSL)
+  target_link_libraries(test_utils PUBLIC PkgConfig::PKG_CONFIG_OPENSSL)
+else()
+  target_link_libraries(test_utils PUBLIC OpenSSL::SSL)
+endif()
+if(MSVC)
+  target_compile_definitions(test_utils PRIVATE _CRT_SECURE_NO_WARNINGS)
+  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    target_compile_options(test_utils PUBLIC -Wno-deprecated-declarations)
+  endif()
+endif()

package/deps/couchbase-cxx-client/test/utils/integration_shortcuts.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2020-Present Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -29,7 +29,7 @@ execute(std::shared_ptr<couchbase::core::cluster> cluster, Request request)
     auto barrier = std::make_shared<std::promise<response_type>>();
     auto f = barrier->get_future();
     cluster->execute(request, [barrier](response_type resp) { barrier->set_value(std::move(resp)); });
-    return std::move(f.get());
+    return f.get();
 }
 
 void
@@ -43,4 +43,4 @@ open_bucket(std::shared_ptr<couchbase::core::cluster> cluster, const std::string
 
 void
 close_bucket(std::shared_ptr<couchbase::core::cluster> cluster, const std::string& bucket_name);
-} // namespace test::utils
+} // namespace test::utils

package/deps/couchbase-cxx-client/test/utils/integration_test_guard.cxx

@@ -53,6 +53,22 @@ spawn_io_threads(asio::io_context& io, std::size_t number_of_threads) -> std::ve
     return threads;
 }
 
+static auto
+build_origin(const test_context& ctx,
+             const couchbase::core::cluster_credentials& auth,
+             const couchbase::core::utils::connection_string& connstr) -> couchbase::core::origin
+{
+    couchbase::core::origin origin(auth, connstr);
+    origin.options().dns_config = couchbase::core::io::dns::dns_config{
+        ctx.dns_nameserver.value_or(couchbase::core::io::dns::dns_config::default_nameserver),
+        ctx.dns_port.value_or(couchbase::core::io::dns::dns_config::default_port),
+    };
+    if (ctx.deployment == deployment_type::capella || ctx.deployment == test::utils::deployment_type::elixir) {
+        origin.options().apply_profile("wan_development");
+    }
+    return origin;
+}
+
 integration_test_guard::integration_test_guard()
   : ctx(test_context::load_from_environment())
   , io(static_cast<int>(ctx.number_of_io_threads))
@@ -69,13 +85,7 @@ integration_test_guard::integration_test_guard()
         auth.password = ctx.password;
     }
     io_threads = spawn_io_threads(io, ctx.number_of_io_threads);
-    origin = couchbase::core::origin(auth, connstr);
-    if (ctx.dns_nameserver || ctx.dns_port) {
-        origin.options().dns_config = couchbase::core::io::dns::dns_config{
-            ctx.dns_nameserver.value_or(couchbase::core::io::dns::dns_config::default_nameserver),
-            ctx.dns_port.value_or(couchbase::core::io::dns::dns_config::default_port),
-        };
-    }
+    origin = build_origin(ctx, auth, connstr);
     open_cluster(cluster, origin);
 }
 
@@ -91,9 +101,9 @@ integration_test_guard::integration_test_guard(const couchbase::core::cluster_op
     connstr.options.meter = opts.meter;
     connstr.options.tracer = opts.tracer;
     connstr.options.enable_mutation_tokens = opts.enable_mutation_tokens;
-    couchbase::core::origin orig(auth, connstr);
+    origin = build_origin(ctx, auth, connstr);
     io_threads = spawn_io_threads(io, ctx.number_of_io_threads);
-    open_cluster(cluster, orig);
+    open_cluster(cluster, origin);
 }
 
 integration_test_guard::~integration_test_guard()
@@ -203,6 +213,7 @@ integration_test_guard::cluster_version()
     auto parsed_version = server_version::parse(runtime_version, ctx.deployment);
     parsed_version.profile = runtime_pools_info.config_profile;
     parsed_version.developer_preview = runtime_pools_info.is_developer_preview;
+    parsed_version.use_gocaves = ctx.version.use_gocaves;
     if (parsed_version.major == 0) {
         /* the build does not specify version properly */
         return ctx.version;

package/deps/couchbase-cxx-client/test/utils/logger.cxx

@@ -32,7 +32,9 @@ init_logger()
         if (auto env_val = spdlog::details::os::getenv("TEST_LOG_LEVEL"); !env_val.empty()) {
             couchbase::core::logger::set_log_levels(couchbase::core::logger::level_from_str(env_val));
         }
-        spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v at %@ %!");
+        if (auto env_val = spdlog::details::os::getenv("TEST_LOG_INCLUDE_LOCATION"); !env_val.empty()) {
+            spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v at %@ %!");
+        }
         initialized = true;
     }
 }

package/deps/couchbase-cxx-client/test/utils/server_version.hxx

@@ -38,8 +38,14 @@ struct server_version {
     server_edition edition{ server_edition::unknown };
     deployment_type deployment{ deployment_type::on_prem };
     server_config_profile profile{ server_config_profile::unknown };
+    bool use_gocaves{ false };
 
-    static server_version parse(const std::string& str, const deployment_type deployment);
+    static server_version parse(const std::string& str, deployment_type deployment);
+
+    [[nodiscard]] bool is_mock() const
+    {
+        return use_gocaves;
+    }
 
     [[nodiscard]] bool is_alice() const
     {
@@ -97,7 +103,7 @@ struct server_version {
 
     [[nodiscard]] bool supports_preserve_expiry() const
     {
-        return is_cheshire_cat() || is_neo();
+        return !use_gocaves && (is_cheshire_cat() || is_neo());
     }
 
     [[nodiscard]] bool supports_preserve_expiry_for_query() const
@@ -112,27 +118,37 @@ struct server_version {
 
     [[nodiscard]] bool supports_query_index_management() const
     {
-        return is_mad_hatter() || is_cheshire_cat() || is_neo();
+        return !use_gocaves && (is_mad_hatter() || is_cheshire_cat() || is_neo());
     }
 
     [[nodiscard]] bool supports_analytics() const
     {
-        return is_enterprise() && (is_mad_hatter() || is_cheshire_cat() || is_neo());
+        return !use_gocaves && is_enterprise() && (is_mad_hatter() || is_cheshire_cat() || is_neo());
+    }
+
+    [[nodiscard]] bool supports_query() const
+    {
+        return !use_gocaves;
+    }
+
+    [[nodiscard]] bool supports_search() const
+    {
+        return !use_gocaves;
     }
 
     [[nodiscard]] bool supports_analytics_pending_mutations() const
     {
-        return is_mad_hatter() || is_cheshire_cat() || is_neo();
+        return supports_analytics() && (is_mad_hatter() || is_cheshire_cat() || is_neo());
     }
 
     [[nodiscard]] bool supports_analytics_link_azure_blob() const
     {
-        return is_cheshire_cat() && developer_preview;
+        return supports_analytics() && is_cheshire_cat() && developer_preview;
     }
 
     [[nodiscard]] bool supports_analytics_links() const
     {
-        return (major == 6 && minor >= 6) || major > 6;
+        return supports_analytics() && ((major == 6 && minor >= 6) || major > 6);
     }
 
     [[nodiscard]] bool supports_minimum_durability_level() const
@@ -142,17 +158,17 @@ struct server_version {
 
     [[nodiscard]] bool supports_search_analyze() const
     {
-        return is_mad_hatter() || is_cheshire_cat() || is_neo();
+        return supports_search() && (is_mad_hatter() || is_cheshire_cat() || is_neo());
     }
 
     [[nodiscard]] bool supports_analytics_links_cert_auth() const
     {
-        return is_neo();
+        return supports_analytics() && is_neo();
     }
 
     [[nodiscard]] bool supports_eventing_functions() const
     {
-        return is_enterprise() && (is_cheshire_cat() || is_neo()) && deployment == deployment_type::on_prem;
+        return !use_gocaves && is_enterprise() && (is_cheshire_cat() || is_neo()) && deployment == deployment_type::on_prem;
     }
 
     [[nodiscard]] bool is_enterprise() const
@@ -167,17 +183,22 @@ struct server_version {
 
     [[nodiscard]] bool supports_bucket_management() const
     {
-        return deployment == deployment_type::on_prem;
+        return !use_gocaves && deployment == deployment_type::on_prem;
     }
 
     [[nodiscard]] bool supports_user_management() const
     {
-        return deployment == deployment_type::on_prem;
+        return !use_gocaves && deployment == deployment_type::on_prem;
+    }
+
+    [[nodiscard]] bool requires_search_replicas() const
+    {
+        return deployment == deployment_type::elixir || deployment == deployment_type::capella || is_serverless_config_profile();
     }
 
     [[nodiscard]] bool supports_views() const
     {
-        return deployment == deployment_type::on_prem && (major < 7 || (major == 7 && minor < 2));
+        return !use_gocaves && deployment == deployment_type::on_prem && (major < 7 || (major == 7 && minor < 2));
     }
 
     [[nodiscard]] bool supports_memcached_buckets() const
@@ -189,6 +210,11 @@ struct server_version {
     {
         return profile == server_config_profile::serverless;
     }
+
+    [[nodiscard]] bool supports_search_disable_scoring() const
+    {
+        return supports_search() && (is_mad_hatter() || is_cheshire_cat() || is_neo());
+    }
 };
 
 } // namespace test::utils

package/deps/couchbase-cxx-client/test/utils/test_context.cxx

@@ -92,6 +92,14 @@ test_context::load_from_environment()
         ctx.number_of_io_threads = std::stoul(var);
     }
 
+    if (auto var = spdlog::details::os::getenv("TEST_USE_GOCAVES"); !var.empty()) {
+        if (var == "true" || var == "yes" || var == "1") {
+            ctx.version.use_gocaves = true;
+        } else if (var == "false" || var == "no" || var == "0") {
+            ctx.version.use_gocaves = false;
+        }
+    }
+
     return ctx;
 }
 } // namespace test::utils

package/deps/couchbase-cxx-client/test/utils/test_data.cxx

@@ -0,0 +1,41 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include <chrono>
+#include <fmt/core.h>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+namespace test::utils
+{
+std::string
+uniq_id(const std::string& prefix)
+{
+    return fmt::format("{}_{}", prefix, std::chrono::steady_clock::now().time_since_epoch().count());
+}
+
+std::string
+read_test_data(const std::string& file)
+{
+    auto ss = std::ostringstream{};
+    std::ifstream input_file(fmt::format("../../test/data/{}", file));
+    ss << input_file.rdbuf();
+    return ss.str();
+}
+} // namespace test::utils

package/deps/couchbase-cxx-client/test/utils/test_data.hxx

@@ -0,0 +1,29 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace test::utils
+{
+std::string
+uniq_id(const std::string& prefix);
+
+std::string
+read_test_data(const std::string& file);
+} // namespace test::utils

package/deps/couchbase-cxx-client/test/utils/wait_until.cxx

@@ -17,6 +17,12 @@
 
 #include "wait_until.hxx"
 
+#include "core/operations/management/bucket_get.hxx"
+#include "core/operations/management/collections_manifest_get.hxx"
+#include "core/operations/management/search_get_stats.hxx"
+#include "core/operations/management/search_index_get_documents_count.hxx"
+#include "core/utils/json.hxx"
+
 namespace test::utils
 {
 bool
@@ -71,6 +77,7 @@ wait_until_user_present(const std::shared_ptr<couchbase::core::cluster>& cluster
     }
     return present;
 }
+
 bool
 wait_until_cluster_connected(const std::string& username, const std::string& password, const std::string& connection_string)
 {
@@ -92,4 +99,58 @@ wait_until_cluster_connected(const std::string& username, const std::string& pas
 
     return connected;
 }
+
+static auto
+to_string(std::optional<std::uint64_t> value) -> std::string
+{
+    if (value) {
+        return std::to_string(*value);
+    }
+    return "(empty)";
+}
+
+bool
+wait_for_search_pindexes_ready(std::shared_ptr<couchbase::core::cluster> cluster,
+                               const std::string& bucket_name,
+                               const std::string& index_name)
+{
+    return test::utils::wait_until(
+      [&]() {
+          couchbase::core::operations::management::search_index_stats_request req{};
+          auto resp = test::utils::execute(cluster, req);
+          if (resp.ctx.ec || resp.stats.empty()) {
+              return false;
+          }
+          auto stats = couchbase::core::utils::json::parse(resp.stats);
+          auto num_pindexes_target = stats.optional<std::uint64_t>(fmt::format("{}:{}:num_pindexes_target", bucket_name, index_name));
+          auto num_pindexes_actual = stats.optional<std::uint64_t>(fmt::format("{}:{}:num_pindexes_actual", bucket_name, index_name));
+
+          CB_LOG_INFO("wait_for_search_pindexes_ready for \"{}\", target: {}, actual: {}",
+                      index_name,
+                      to_string(num_pindexes_target),
+                      to_string(num_pindexes_actual));
+
+          if (num_pindexes_actual && num_pindexes_target) {
+              return num_pindexes_actual.value() == num_pindexes_target.value();
+          }
+          return false;
+      },
+      std::chrono::minutes(5));
+}
+
+bool
+wait_until_indexed(std::shared_ptr<couchbase::core::cluster> cluster, const std::string& index_name, std::uint64_t expected_count)
+{
+    return test ::utils::wait_until(
+      [cluster = std::move(cluster), &index_name, &expected_count]() {
+          couchbase::core::operations::management::search_index_get_documents_count_request req{};
+          req.index_name = index_name;
+          req.timeout = std::chrono::seconds{ 1 };
+          auto resp = test::utils::execute(cluster, req);
+          CB_LOG_INFO("wait_until_indexed for \"{}\", expected: {}, actual: {}", index_name, expected_count, resp.count);
+          return resp.count >= expected_count;
+      },
+      std::chrono::minutes(5));
+}
+
 } // namespace test::utils

package/deps/couchbase-cxx-client/test/utils/wait_until.hxx

@@ -24,7 +24,6 @@
 #include "core/operations/management/collections.hxx"
 #include "core/operations/management/user.hxx"
 #include "couchbase/cluster.hxx"
-#include "couchbase/cluster_options.hxx"
 
 namespace test::utils
 {
@@ -68,4 +67,12 @@ wait_until_user_present(const std::shared_ptr<couchbase::core::cluster>& cluster
 
 bool
 wait_until_cluster_connected(const std::string& username, const std::string& password, const std::string& connection_string);
+
+bool
+wait_for_search_pindexes_ready(std::shared_ptr<couchbase::core::cluster> cluster,
+                               const std::string& bucket_name,
+                               const std::string& index_name);
+
+bool
+wait_until_indexed(std::shared_ptr<couchbase::core::cluster> cluster, const std::string& index_name, std::uint64_t expected_count);
 } // namespace test::utils

package/deps/couchbase-cxx-client/third_party/catch2/.bazelrc

@@ -0,0 +1,10 @@
+build --enable_platform_specific_config
+
+build:gcc9 --cxxopt=-std=c++2a
+build:gcc11 --cxxopt=-std=c++2a
+build:clang13 --cxxopt=-std=c++17
+build:vs2019 --cxxopt=/std:c++17
+build:vs2022 --cxxopt=/std:c++17
+
+build:windows --config=vs2022
+build:linux --config=gcc11

package/deps/couchbase-cxx-client/third_party/catch2/.conan/build.py

@@ -26,8 +26,8 @@ class BuilderSettings(object):
         """ Set Catch2 repository to be used on upload.
             The upload server address could be customized by env var
             CONAN_UPLOAD. If not defined, the method will check the branch name.
-            Only master or CONAN_STABLE_BRANCH_PATTERN will be accepted.
-            The master branch will be pushed to testing channel, because it does
+            Only devel or CONAN_STABLE_BRANCH_PATTERN will be accepted.
+            The devel branch will be pushed to testing channel, because it does
             not match the stable pattern. Otherwise it will upload to stable
             channel.
         """
@@ -49,7 +49,7 @@ class BuilderSettings(object):
     def reference(self):
         """ Read project version from branch create Conan reference
         """
-        return os.getenv("CONAN_REFERENCE", "Catch2/{}".format(self._version))
+        return os.getenv("CONAN_REFERENCE", "catch2/{}".format(self._version))
 
     @property
     def channel(self):
@@ -85,7 +85,7 @@ if __name__ == "__main__":
         reference=settings.reference,
         channel=settings.channel,
         upload=settings.upload,
-        upload_only_when_stable=settings.upload_only_when_stable,
+        upload_only_when_stable=False,
         stable_branch_pattern=settings.stable_branch_pattern,
         login_username=settings.login_username,
         username=settings.username,

package/deps/couchbase-cxx-client/third_party/catch2/.conan/test_package/CMakeLists.txt

@@ -1,11 +1,12 @@
 cmake_minimum_required(VERSION 3.2.0)
 project(test_package CXX)
 
-include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
-conan_basic_setup(TARGETS)
+include("${CMAKE_BINARY_DIR}/conanbuildinfo.cmake")
+conan_basic_setup()
 
 find_package(Catch2 REQUIRED CONFIG)
 
 add_executable(${PROJECT_NAME} test_package.cpp)
-target_link_libraries(${PROJECT_NAME} CONAN_PKG::Catch2)
-set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD 11)
+
+target_link_libraries(${PROJECT_NAME} Catch2::Catch2WithMain)
+set_target_properties(${PROJECT_NAME} PROPERTIES CXX_STANDARD 14)