couchbase 4.2.1 → 4.2.3

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

@@ -18,7 +18,7 @@
 #include "test_helper.hxx"
 
 #include "core/cluster_options.hxx"
-#include "core/config_profile.hxx"
+#include "core/config_profiles.hxx"
 #include <stdexcept>
 
 class test_profile : public couchbase::core::config_profile
@@ -52,14 +52,17 @@ TEST_CASE("unit: can apply wan_development profile", "[unit]")
     // for details and latest info on expectations.
     couchbase::core::cluster_options opts{};
     opts.apply_profile("wan_development");
-    CHECK(opts.key_value_timeout.count() == 20000);
-    CHECK(opts.key_value_durable_timeout.count() == 20000);
-    CHECK(opts.connect_timeout.count() == 20000);
-    CHECK(opts.view_timeout.count() == 120000);
-    CHECK(opts.query_timeout.count() == 120000);
-    CHECK(opts.analytics_timeout.count() == 120000);
-    CHECK(opts.search_timeout.count() == 120000);
-    CHECK(opts.management_timeout.count() == 120000);
+    CHECK(opts.key_value_timeout.count() == 20'000);
+    CHECK(opts.key_value_durable_timeout.count() == 20'000);
+    CHECK(opts.connect_timeout.count() == 20'000);
+    CHECK(opts.view_timeout.count() == 120'000);
+    CHECK(opts.query_timeout.count() == 120'000);
+    CHECK(opts.analytics_timeout.count() == 120'000);
+    CHECK(opts.search_timeout.count() == 120'000);
+    CHECK(opts.management_timeout.count() == 120'000);
+    CHECK(opts.bootstrap_timeout.count() == 120'000);
+    CHECK(opts.resolve_timeout.count() == 20'000);
+    CHECK(opts.dns_config.timeout().count() == 20'000);
 }
 
 TEST_CASE("unit: all other options remain unchanged", "[unit]")
@@ -71,11 +74,9 @@ TEST_CASE("unit: all other options remain unchanged", "[unit]")
     // we'd expect default_opts to be equal to opts:
     CHECK(opts.tracer == default_opts.tracer);
     CHECK(opts.meter == default_opts.meter);
-    CHECK(opts.bootstrap_timeout == default_opts.bootstrap_timeout);
     CHECK(opts.config_idle_redial_timeout == default_opts.config_idle_redial_timeout);
     CHECK(opts.config_poll_floor == default_opts.config_poll_floor);
     CHECK(opts.config_poll_interval == default_opts.config_poll_interval);
-    CHECK(opts.dns_srv_timeout == default_opts.dns_srv_timeout);
     CHECK(opts.enable_clustermap_notification == opts.enable_clustermap_notification);
     CHECK(opts.enable_compression == default_opts.enable_compression);
     CHECK(opts.enable_dns_srv == default_opts.enable_dns_srv);
@@ -88,7 +89,6 @@ TEST_CASE("unit: all other options remain unchanged", "[unit]")
     CHECK(opts.idle_http_connection_timeout == default_opts.idle_http_connection_timeout);
     CHECK(opts.max_http_connections == default_opts.max_http_connections);
     CHECK(opts.network == default_opts.network);
-    CHECK(opts.resolve_timeout == default_opts.resolve_timeout);
     CHECK(opts.show_queries == default_opts.show_queries);
     CHECK(opts.tcp_keep_alive_interval == default_opts.tcp_keep_alive_interval);
     CHECK(opts.tls_verify == default_opts.tls_verify);
@@ -129,4 +129,4 @@ TEST_CASE("unit: can have profile with constructor args", "[unit]")
                                                                                std::string("something_extra"));
     opts.apply_profile("test_with_args");
     CHECK(opts.user_agent_extra == "something_extra");
-}
+}

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

@@ -52,6 +52,8 @@ TEST_CASE("unit: connection string", "[unit]")
         CHECK(couchbase::core::utils::parse_connection_string("http://127.0.0.1").scheme == "http");
         CHECK(couchbase::core::utils::parse_connection_string("couchbase://").scheme == "couchbase");
         CHECK(couchbase::core::utils::parse_connection_string("my+scheme://").scheme == "my+scheme");
+        CHECK(couchbase::core::utils::parse_connection_string("127.0.0.1").scheme == "couchbase");
+        CHECK(couchbase::core::utils::parse_connection_string("127.0.0.1:8091").scheme == "couchbase");
 
         SECTION("default bootstrap mode")
         {
@@ -155,6 +157,13 @@ TEST_CASE("unit: connection string", "[unit]")
                       couchbase::core::utils::connection_string::address_type::dns,
                       couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
                   });
+            CHECK(couchbase::core::utils::parse_connection_string("1.2.3.4").bootstrap_nodes ==
+                  std::vector<couchbase::core::utils::connection_string::node>{
+                    { "1.2.3.4",
+                      0,
+                      couchbase::core::utils::connection_string::address_type::ipv4,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                  });
         }
 
         SECTION("multiple nodes")
@@ -207,6 +216,17 @@ TEST_CASE("unit: connection string", "[unit]")
                       couchbase::core::utils::connection_string::address_type::ipv4,
                       couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
                   });
+            CHECK(couchbase::core::utils::parse_connection_string("1.2.3.4,4.3.2.1").bootstrap_nodes ==
+                  std::vector<couchbase::core::utils::connection_string::node>{
+                    { "1.2.3.4",
+                      0,
+                      couchbase::core::utils::connection_string::address_type::ipv4,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                    { "4.3.2.1",
+                      0,
+                      couchbase::core::utils::connection_string::address_type::ipv4,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                  });
         }
 
         SECTION("custom ports")
@@ -259,6 +279,21 @@ TEST_CASE("unit: connection string", "[unit]")
                       couchbase::core::utils::connection_string::address_type::ipv4,
                       couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
                   });
+            CHECK(couchbase::core::utils::parse_connection_string("example.com:123,[::1]:456;127.0.0.1:789").bootstrap_nodes ==
+                  std::vector<couchbase::core::utils::connection_string::node>{
+                    { "example.com",
+                      123,
+                      couchbase::core::utils::connection_string::address_type::dns,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                    { "::1",
+                      456,
+                      couchbase::core::utils::connection_string::address_type::ipv6,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                    { "127.0.0.1",
+                      789,
+                      couchbase::core::utils::connection_string::address_type::ipv4,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                  });
         }
 
         SECTION("custom bootstrap mode")

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

@@ -17,10 +17,14 @@
 
 #include "test_helper.hxx"
 
+#include <catch2/catch_approx.hpp>
+
 #include <couchbase/codec/default_json_transcoder.hxx>
 
 #include <tao/json.hpp>
 
+using Catch::Approx;
+
 TEST_CASE("unit: default_json_transcoder encodes primitives", "[unit]")
 {
     {

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

@@ -14,9 +14,11 @@
  *   limitations under the License.
  */
 
-#include "core/transactions/internal/logging.hxx"
+#include "test/utils/wait_until.hxx"
 #include "test_helper.hxx"
-#include <core/transactions.hxx>
+#include <core/logger/configuration.hxx>
+#include <core/logger/logger.hxx>
+#include <core/transactions/internal/logging.hxx>
 
 #include <spdlog/sinks/base_sink.h>
 
@@ -28,8 +30,10 @@ using namespace couchbase::core::transactions;
 class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
 {
   public:
-    std::string output() const
+    std::string output()
     {
+        // prevent data race if sink_it_ is called
+        std::lock_guard<std::mutex> lock(mut_);
         return out_.str();
     }
 
@@ -38,6 +42,8 @@ class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
     {
         spdlog::memory_buf_t formatted;
         base_sink<std::mutex>::formatter_->format(msg, formatted);
+        // prevent data race when calling output()
+        std::lock_guard<std::mutex> lock(mut_);
         out_ << formatted.data();
     }
     void flush_() override
@@ -46,41 +52,79 @@ class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
 
   private:
     std::stringstream out_;
+    // needed since we examine the internal state of this object
+    std::mutex mut_;
 };
 
+bool
+sink_has_output(std::shared_ptr<TrivialFileSink> sink)
+{
+    return test::utils::wait_until([&]() { return !sink->output().empty(); }, std::chrono::seconds(2), std::chrono::milliseconds(100));
+}
+
+bool
+sink_is_empty(std::shared_ptr<TrivialFileSink> sink)
+{
+    // now, we need to be sure it is empty, and stays that way for some period of time,
+    // since async loggers don't flush immediately.   The logger is set to flush every
+    // second, so waiting 2 or 3 seems reasonable
+    if (sink->output().empty()) {
+        std::this_thread::sleep_for(std::chrono::seconds(2));
+        return sink->output().empty();
+    }
+    return false;
+}
+
+bool
+sink_output_contains(std::shared_ptr<TrivialFileSink> sink, const std::string& msg)
+{
+    return std::string::npos != sink->output().find(msg);
+}
+
+void
+create_logger(std::shared_ptr<TrivialFileSink> sink, couchbase::core::logger::level level)
+{
+    couchbase::core::logger::configuration conf{};
+    conf.log_level = level;
+    conf.sink = sink;
+    conf.console = false;
+    couchbase::core::logger::create_file_logger(conf);
+}
+
 TEST_CASE("transactions: can use custom sink", "[unit]")
 {
-    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
     auto sink = std::make_shared<TrivialFileSink>();
-    create_loggers(couchbase::core::logger::level::debug, sink);
-    txn_log->debug(log_message);
-    txn_log->flush();
-    REQUIRE_FALSE(sink->output().empty());
-    REQUIRE(std::string::npos != sink->output().find(log_message));
+    create_logger(sink, couchbase::core::logger::level::trace);
+    CB_TXN_LOG_DEBUG(log_message);
+    couchbase::core::logger::flush();
+    // ASYNC logger, so flush returns immediately.   Gotta wait...
+    REQUIRE(sink_has_output(sink));
+    REQUIRE(sink_output_contains(sink, log_message));
 }
 
 TEST_CASE("transactions: custom sink respects log levels", "[unit]")
 {
-    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
+    std::string log_message2 = "I am also a log";
     auto sink = std::make_shared<TrivialFileSink>();
-    create_loggers(couchbase::core::logger::level::info, sink);
-    txn_log->debug(log_message);
-    txn_log->flush();
-    REQUIRE(sink->output().empty());
-    couchbase::core::logger::create_console_logger();
+    create_logger(sink, couchbase::core::logger::level::info);
+    CB_TXN_LOG_DEBUG(log_message);
+    couchbase::core::logger::flush();
+    REQUIRE(sink_is_empty(sink));
+    CB_TXN_LOG_INFO(log_message2);
+    couchbase::core::logger::flush();
+    REQUIRE(sink_has_output(sink));
+    REQUIRE(sink_output_contains(sink, log_message2));
 }
 
 TEST_CASE("transactions: custom sink respects log level changes", "[unit]")
 {
-    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
     auto sink = std::make_shared<TrivialFileSink>();
-    create_loggers(couchbase::core::logger::level::debug, sink);
-    set_transactions_log_level(couchbase::core::logger::level::info);
-    txn_log->debug(log_message);
-    txn_log->flush();
-    REQUIRE(sink->output().empty());
-    couchbase::core::logger::create_console_logger();
+    create_logger(sink, couchbase::core::logger::level::trace);
+    couchbase::core::logger::set_log_levels(couchbase::core::logger::level::info);
+    CB_TXN_LOG_DEBUG(log_message);
+    couchbase::core::logger::flush();
+    REQUIRE(sink_is_empty(sink));
 }

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));
@@ -211,3 +215,54 @@ TEST_CASE("unit: base64", "[unit]")
     REQUIRE(couchbase::core::base64::encode(binary, false) == base64);
     REQUIRE(couchbase::core::base64::encode(binary, true) == base64_pretty);
 }
+
+namespace couchbase::core::meta
+{
+std::string
+parse_git_describe_output(const std::string& git_describe_output);
+}
+
+TEST_CASE("unit: semantic version string", "[unit]")
+{
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0-beta.4-16-gfbc9922") == "1.0.0-beta.4+16.fbc9922");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0-16-gfbc9922") == "1.0.0+16.fbc9922");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("") == "");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("unknown") == "");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("invalid") == "");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0.0.0") == "");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0-beta.4-0-gfbc9922") == "1.0.0-beta.4");
+    REQUIRE(couchbase::core::meta::parse_git_describe_output("1.0.0-beta.4") == "1.0.0-beta.4");
+}
+
+#if 0
+// This test is commented out because, it is not necessary to run it with the suite, but it still useful for debugging.
+
+#include "core/platform/uuid.h"
+
+TEST_CASE("unit: uuid collision", "[unit]")
+{
+    std::array<std::set<std::string>, 10> uuids{};
+    std::vector<std::thread> threads{};
+    threads.reserve(10);
+
+    for (std::size_t t = 0; t < 10; ++t) {
+        threads.emplace_back([&uuids, t]() {
+            for (std::size_t i = 0; i < 1'000'000; ++i) {
+                auto uuid = couchbase::core::uuid::to_string(couchbase::core::uuid::random());
+                uuids[t].insert(uuid);
+            }
+        });
+    }
+    for (std::size_t t = 0; t < 10; ++t) {
+        threads[t].join();
+        REQUIRE(uuids[t].size() == 1'000'000);
+    }
+
+    std::set<std::string> all_uuids{};
+    for (std::size_t t = 0; t < 10; ++t) {
+        for (const auto& uuid : uuids[t]) {
+            REQUIRE(all_uuids.insert(uuid).second);
+        }
+    }
+}
+#endif

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) {
+        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);
 }
 
@@ -90,14 +100,16 @@ integration_test_guard::integration_test_guard(const couchbase::core::cluster_op
     // for now, lets _only_ add a tracer or meter from the incoming options
     connstr.options.meter = opts.meter;
     connstr.options.tracer = opts.tracer;
-    couchbase::core::origin orig(auth, connstr);
+    connstr.options.enable_mutation_tokens = opts.enable_mutation_tokens;
+    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()
 {
     close_cluster(cluster);
+    io.stop();
     for (auto& thread : io_threads) {
         thread.join();
     }

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

@@ -175,6 +175,11 @@ struct server_version {
         return deployment == deployment_type::on_prem;
     }
 
+    [[nodiscard]] bool requires_search_replicas() const
+    {
+        return 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));
@@ -189,6 +194,11 @@ struct server_version {
     {
         return profile == server_config_profile::serverless;
     }
+
+    [[nodiscard]] bool supports_search_disable_scoring() const
+    {
+        return is_mad_hatter() || is_cheshire_cat() || is_neo();
+    }
 };
 
 } // 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