couchbase 4.1.1 → 4.1.2

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

@@ -18,6 +18,7 @@
 #include "test_helper_integration.hxx"
 
 #include <couchbase/cas_fmt.hxx>
+#include <couchbase/utils/binary.hxx>
 
 TEST_CASE("integration: append", "[integration]")
 {
@@ -27,7 +28,7 @@ TEST_CASE("integration: append", "[integration]")
 
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
     {
-        couchbase::operations::upsert_request req{ id, "world" };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary("world") };
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
@@ -37,7 +38,7 @@ TEST_CASE("integration: append", "[integration]")
         REQUIRE(resp.token.sequence_number != 0);
     }
     {
-        couchbase::operations::append_request req{ id, "!" };
+        couchbase::operations::append_request req{ id, couchbase::utils::to_binary("!") };
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
@@ -51,8 +52,7 @@ TEST_CASE("integration: append", "[integration]")
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
         REQUIRE(!resp.cas.empty());
-        INFO("value=" << resp.value)
-        REQUIRE(resp.value == "world!");
+        REQUIRE(resp.value == couchbase::utils::to_binary("world!"));
     }
 }
 
@@ -64,7 +64,7 @@ TEST_CASE("integration: prepend", "[integration]")
 
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
     {
-        couchbase::operations::upsert_request req{ id, "world" };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary("world") };
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
@@ -73,7 +73,7 @@ TEST_CASE("integration: prepend", "[integration]")
         REQUIRE(resp.token.sequence_number != 0);
     }
     {
-        couchbase::operations::prepend_request req{ id, "Hello, " };
+        couchbase::operations::prepend_request req{ id, couchbase::utils::to_binary("Hello, ") };
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
@@ -87,8 +87,7 @@ TEST_CASE("integration: prepend", "[integration]")
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
         REQUIRE(!resp.cas.empty());
-        INFO("value=" << resp.value)
-        REQUIRE(resp.value == "Hello, world");
+        REQUIRE(resp.value == couchbase::utils::to_binary("Hello, world"));
     }
 }
 
@@ -101,14 +100,14 @@ TEST_CASE("integration: binary ops on missing document", "[integration]")
 
     SECTION("append")
     {
-        couchbase::operations::append_request req{ id, "" };
+        couchbase::operations::append_request req{ id, couchbase::utils::to_binary("") };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
     }
 
     SECTION("prepend")
     {
-        couchbase::operations::prepend_request req{ id, "" };
+        couchbase::operations::prepend_request req{ id, couchbase::utils::to_binary("") };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
     }

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

@@ -43,7 +43,7 @@ TEST_CASE("integration: missing scope and collection", "[integration]")
             { "a", 1.0 },
             { "b", 2.0 },
         };
-        couchbase::operations::insert_request req{ id, couchbase::utils::json::generate(value) };
+        couchbase::operations::insert_request req{ id, couchbase::utils::json::generate_binary(value) };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::common_errc::scope_not_found);
     }
@@ -64,7 +64,7 @@ TEST_CASE("integration: missing scope and collection", "[integration]")
             { "a", 1.0 },
             { "b", 2.0 },
         };
-        couchbase::operations::insert_request req{ id, couchbase::utils::json::generate(value) };
+        couchbase::operations::insert_request req{ id, couchbase::utils::json::generate_binary(value) };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::common_errc::ambiguous_timeout);
         REQUIRE(resp.ctx.retry_reasons.count(couchbase::io::retry_reason::kv_collection_outdated) == 1);
@@ -102,7 +102,7 @@ TEST_CASE("integration: get and insert non default scope and collection", "[inte
     }
 
     {
-        couchbase::operations::insert_request req{ id, key };
+        couchbase::operations::insert_request req{ id, couchbase::utils::to_binary(key) };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
     }
@@ -111,7 +111,7 @@ TEST_CASE("integration: get and insert non default scope and collection", "[inte
         couchbase::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == key);
+        REQUIRE(resp.value == couchbase::utils::to_binary(key));
     }
 }
 
@@ -146,7 +146,7 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
     }
 
     {
-        couchbase::operations::insert_request req{ id, key };
+        couchbase::operations::insert_request req{ id, couchbase::utils::to_binary(key) };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
     }
@@ -155,7 +155,7 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
         couchbase::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == key);
+        REQUIRE(resp.value == couchbase::utils::to_binary(key));
     }
 
     {
@@ -167,7 +167,7 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
     }
 
     {
-        couchbase::operations::upsert_request req{ id, key };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(key) };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::common_errc::scope_not_found);
     }

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

@@ -131,7 +131,7 @@ TEST_CASE("integration: destroy cluster without waiting for close completion", "
     // hit KV
     {
         couchbase::document_id id{ ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
-        couchbase::operations::upsert_request req{ id, "{{}}" };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary("{{}}") };
         auto resp = test::utils::execute(cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
     }

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

@@ -23,7 +23,7 @@ static const tao::json::value basic_doc = {
     { "a", 1.0 },
     { "b", 2.0 },
 };
-static const std::string basic_doc_json = couchbase::utils::json::generate(basic_doc);
+static const std::vector<std::byte> basic_doc_json = couchbase::utils::json::generate_binary(basic_doc);
 
 TEST_CASE("integration: crud on default collection", "[integration]")
 {
@@ -53,7 +53,7 @@ TEST_CASE("integration: crud on default collection", "[integration]")
     // update
     {
         auto doc = basic_doc;
-        auto json = couchbase::utils::json::generate(doc);
+        auto json = couchbase::utils::json::generate_binary(doc);
         doc["a"] = 2.0;
 
         {
@@ -170,7 +170,7 @@ TEST_CASE("integration: pessimistic locking", "[integration]")
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("locking") };
     uint32_t lock_time = 10;
 
-    couchbase::cas cas;
+    couchbase::cas cas{};
 
     {
         couchbase::operations::insert_request req{ id, basic_doc_json };
@@ -260,7 +260,7 @@ TEST_CASE("integration: lock/unlock without lock time", "[integration]")
         REQUIRE_FALSE(resp.ctx.ec);
     }
 
-    couchbase::cas cas;
+    couchbase::cas cas{};
 
     {
         couchbase::operations::get_and_lock_request req{ id };
@@ -380,7 +380,7 @@ TEST_CASE("integration: zero length value", "[integration]")
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("zero_length_value") };
 
     {
-        couchbase::operations::insert_request req{ id, "" };
+        couchbase::operations::insert_request req{ id, couchbase::utils::to_binary("") };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
     }
@@ -389,7 +389,7 @@ TEST_CASE("integration: zero length value", "[integration]")
         couchbase::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == "");
+        REQUIRE(resp.value == couchbase::utils::to_binary(""));
     }
 }
 
@@ -416,7 +416,7 @@ TEST_CASE("integration: ops on missing document", "[integration]")
 
     SECTION("replace")
     {
-        couchbase::operations::replace_request req{ id, "" };
+        couchbase::operations::replace_request req{ id, couchbase::utils::to_binary("") };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
     }
@@ -428,7 +428,7 @@ TEST_CASE("integration: cas replace", "[integration]")
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("cas_replace") };
-    couchbase::cas cas;
+    couchbase::cas cas{};
 
     {
         couchbase::operations::insert_request req{ id, basic_doc_json };
@@ -439,7 +439,7 @@ TEST_CASE("integration: cas replace", "[integration]")
 
     SECTION("incorrect")
     {
-        couchbase::operations::replace_request req{ id, "" };
+        couchbase::operations::replace_request req{ id, couchbase::utils::to_binary("") };
         req.cas = couchbase::cas{ cas.value + 1 };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::common_errc::cas_mismatch);
@@ -447,7 +447,7 @@ TEST_CASE("integration: cas replace", "[integration]")
 
     SECTION("correct")
     {
-        couchbase::operations::replace_request req{ id, "" };
+        couchbase::operations::replace_request req{ id, couchbase::utils::to_binary("") };
         req.cas = cas;
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -466,7 +466,7 @@ TEST_CASE("integration: upsert preserve expiry", "[integration]")
 
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("preserve_expiry") };
     uint32_t expiry = std::numeric_limits<uint32_t>::max();
-    auto expiry_path = "$document.exptime";
+    const auto* expiry_path = "$document.exptime";
 
     {
         couchbase::operations::upsert_request req{ id, basic_doc_json };
@@ -518,7 +518,7 @@ TEST_CASE("integration: upsert with handler capturing non-copyable object", "[in
 
     {
         couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
-        couchbase::operations::upsert_request req{ id, R"({"foo":"bar"})" };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(R"({"foo":"bar"})") };
         auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
         auto f = barrier->get_future();
         test::utils::move_only_context ctx("foobar");
@@ -540,7 +540,7 @@ TEST_CASE("integration: upsert may trigger snappy compression", "[integration]")
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
 
-    std::string compressible_json = R"(
+    auto compressible_json = couchbase::utils::to_binary(R"(
 {
   "name": "Emmy-lou Dickerson",
   "age": 26,
@@ -569,7 +569,7 @@ TEST_CASE("integration: upsert may trigger snappy compression", "[integration]")
     ]
   }
 }
-)";
+)");
 
     // create
     {

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

@@ -358,8 +358,80 @@ TEST_CASE("integration: ping", "[integration]")
         integration.cluster->ping(
           "my_report_id", {}, {}, [barrier](couchbase::diag::ping_result&& resp) mutable { barrier->set_value(std::move(resp)); });
         auto res = f.get();
+        REQUIRE(res.services.size() > 0);
+
+        REQUIRE(res.services.count(couchbase::service_type::key_value) > 0);
+        REQUIRE(res.services[couchbase::service_type::key_value].size() > 0);
+
+        REQUIRE(res.services.count(couchbase::service_type::management) > 0);
+        REQUIRE(res.services[couchbase::service_type::management].size() > 0);
+
+        REQUIRE(res.services.count(couchbase::service_type::view) > 0);
+        REQUIRE(res.services[couchbase::service_type::view].size() > 0);
+
+        REQUIRE(res.services.count(couchbase::service_type::query) > 0);
+        REQUIRE(res.services[couchbase::service_type::query].size() > 0);
+
+        REQUIRE(res.services.count(couchbase::service_type::search) > 0);
+        REQUIRE(res.services[couchbase::service_type::search].size() > 0);
+
+        if (integration.ctx.version.supports_analytics()) {
+            REQUIRE(res.services.count(couchbase::service_type::analytics) > 0);
+            REQUIRE(res.services[couchbase::service_type::analytics].size() > 0);
+        }
+
+        if (integration.ctx.version.supports_eventing_functions()) {
+            REQUIRE(res.services.count(couchbase::service_type::eventing) > 0);
+            REQUIRE(res.services[couchbase::service_type::eventing].size() > 0);
+        }
+
         REQUIRE(res.id == "my_report_id");
         INFO(res.sdk)
         REQUIRE(res.sdk.find("cxx/") == 0);
     }
 }
+
+TEST_CASE("integration: ping allows to select services", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    {
+        auto barrier = std::make_shared<std::promise<couchbase::diag::ping_result>>();
+        auto f = barrier->get_future();
+        integration.cluster->ping({},
+                                  {},
+                                  { couchbase::service_type::key_value, couchbase::service_type::query },
+                                  [barrier](couchbase::diag::ping_result&& resp) mutable { barrier->set_value(std::move(resp)); });
+        auto res = f.get();
+        REQUIRE(res.services.size() == 2);
+
+        REQUIRE(res.services.count(couchbase::service_type::key_value) > 0);
+        REQUIRE(res.services[couchbase::service_type::key_value].size() > 0);
+
+        REQUIRE(res.services.count(couchbase::service_type::query) > 0);
+        REQUIRE(res.services[couchbase::service_type::query].size() > 0);
+    }
+}
+
+TEST_CASE("integration: ping allows to select bucket and opens it automatically", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+
+    {
+        auto barrier = std::make_shared<std::promise<couchbase::diag::ping_result>>();
+        auto f = barrier->get_future();
+        integration.cluster->ping({},
+                                  integration.ctx.bucket,
+                                  { couchbase::service_type::key_value },
+                                  [barrier](couchbase::diag::ping_result&& resp) mutable { barrier->set_value(std::move(resp)); });
+        auto res = f.get();
+        REQUIRE(res.services.size() == 1);
+
+        REQUIRE(res.services.count(couchbase::service_type::key_value) > 0);
+        REQUIRE(res.services[couchbase::service_type::key_value].size() > 0);
+        REQUIRE(res.services[couchbase::service_type::key_value][0].bucket.has_value());
+        REQUIRE(res.services[couchbase::service_type::key_value][0].bucket.value() == integration.ctx.bucket);
+    }
+}

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

@@ -32,7 +32,7 @@ TEST_CASE("integration: durable operations", "[integration]")
             { "a", 1.0 },
             { "b", 2.0 },
         };
-        couchbase::operations::upsert_request req{ id, couchbase::utils::json::generate(value) };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::json::generate_binary(value) };
         req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
@@ -44,7 +44,7 @@ TEST_CASE("integration: durable operations", "[integration]")
         const tao::json::value value = {
             { "foo", "bar" },
         };
-        couchbase::operations::replace_request req{ id, couchbase::utils::json::generate(value) };
+        couchbase::operations::replace_request req{ id, couchbase::utils::json::generate_binary(value) };
         req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
@@ -68,7 +68,7 @@ TEST_CASE("integration: durable operations", "[integration]")
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
         REQUIRE(!resp.cas.empty());
-        REQUIRE(resp.value == R"({"foo":"bar","baz":42})");
+        REQUIRE(resp.value == couchbase::utils::to_binary(R"({"foo":"bar","baz":42})"));
     }
     {
         couchbase::operations::remove_request req{ id };

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

@@ -159,7 +159,7 @@ TEST_CASE("integration: bucket management", "[integration]")
             REQUIRE_FALSE(resp.ctx.ec);
             REQUIRE(!resp.buckets.empty());
             auto known_buckets =
-              std::count_if(resp.buckets.begin(), resp.buckets.end(), [bucket_name](auto& entry) { return entry.name == bucket_name; });
+              std::count_if(resp.buckets.begin(), resp.buckets.end(), [&bucket_name](auto& entry) { return entry.name == bucket_name; });
             REQUIRE(known_buckets == 0);
         }
     }
@@ -186,7 +186,7 @@ TEST_CASE("integration: bucket management", "[integration]")
                 const tao::json::value value = {
                     { "a", 1.0 },
                 };
-                couchbase::operations::insert_request req{ id, couchbase::utils::json::generate(value) };
+                couchbase::operations::insert_request req{ id, couchbase::utils::json::generate_binary(value) };
                 auto resp = test::utils::execute(integration.cluster, req);
                 REQUIRE_FALSE(resp.ctx.ec);
             }
@@ -461,11 +461,11 @@ TEST_CASE("integration: bucket management", "[integration]")
     }
 }
 
-bool
-collection_exists(std::shared_ptr<couchbase::cluster> cluster,
-                  const std::string& bucket_name,
-                  const std::string& scope_name,
-                  const std::string& collection_name)
+std::optional<couchbase::topology::collections_manifest::collection>
+get_collection(std::shared_ptr<couchbase::cluster> cluster,
+               const std::string& bucket_name,
+               const std::string& scope_name,
+               const std::string& collection_name)
 {
     couchbase::operations::management::scope_get_all_request req{ bucket_name };
     auto resp = test::utils::execute(cluster, req);
@@ -474,13 +474,13 @@ collection_exists(std::shared_ptr<couchbase::cluster> cluster,
             if (scope.name == scope_name) {
                 for (const auto& collection : scope.collections) {
                     if (collection.name == collection_name) {
-                        return true;
+                        return collection;
                     }
                 }
             }
         }
     }
-    return false;
+    return std::nullopt;
 }
 
 bool
@@ -509,6 +509,7 @@ TEST_CASE("integration: collection management", "[integration]")
 
     auto scope_name = test::utils::uniq_id("scope");
     auto collection_name = test::utils::uniq_id("collection");
+    std::uint32_t max_expiry = 5;
 
     {
         couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
@@ -532,7 +533,7 @@ TEST_CASE("integration: collection management", "[integration]")
     {
         couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
         if (integration.cluster_version().is_enterprise()) {
-            req.max_expiry = 5;
+            req.max_expiry = max_expiry;
         }
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -541,13 +542,21 @@ TEST_CASE("integration: collection management", "[integration]")
     }
 
     {
-        auto created = test::utils::wait_until(
-          [&]() { return collection_exists(integration.cluster, integration.ctx.bucket, scope_name, collection_name); });
+        couchbase::topology::collections_manifest::collection collection;
+        auto created = test::utils::wait_until([&]() {
+            auto coll = get_collection(integration.cluster, integration.ctx.bucket, scope_name, collection_name);
+            if (coll) {
+                collection = *coll;
+                return true;
+            }
+            return false;
+        });
         REQUIRE(created);
+        if (integration.cluster_version().is_enterprise()) {
+            REQUIRE(collection.max_expiry == max_expiry);
+        }
     }
 
-    // TODO: Check collection was created with correct max expiry when supported
-
     {
         couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
         auto resp = test::utils::execute(integration.cluster, req);
@@ -562,7 +571,7 @@ TEST_CASE("integration: collection management", "[integration]")
 
     {
         auto dropped = test::utils::wait_until(
-          [&]() { return !collection_exists(integration.cluster, integration.ctx.bucket, scope_name, collection_name); });
+          [&]() { return !get_collection(integration.cluster, integration.ctx.bucket, scope_name, collection_name).has_value(); });
         REQUIRE(dropped);
     }
 
@@ -1562,7 +1571,7 @@ TEST_CASE("integration: analytics index management", "[integration]")
             auto resp = test::utils::execute(integration.cluster, req);
             REQUIRE_FALSE(resp.ctx.ec);
             REQUIRE_FALSE(resp.datasets.empty());
-            auto dataset = std::find_if(resp.datasets.begin(), resp.datasets.end(), [dataset_name](const auto& exp_dataset) {
+            auto dataset = std::find_if(resp.datasets.begin(), resp.datasets.end(), [&dataset_name](const auto& exp_dataset) {
                 return exp_dataset.name == dataset_name;
             });
             REQUIRE(dataset != resp.datasets.end());
@@ -1577,7 +1586,7 @@ TEST_CASE("integration: analytics index management", "[integration]")
             REQUIRE_FALSE(resp.ctx.ec);
             REQUIRE_FALSE(resp.indexes.empty());
             auto index = std::find_if(
-              resp.indexes.begin(), resp.indexes.end(), [index_name](const auto& exp_index) { return exp_index.name == index_name; });
+              resp.indexes.begin(), resp.indexes.end(), [&index_name](const auto& exp_index) { return exp_index.name == index_name; });
             REQUIRE(index != resp.indexes.end());
             REQUIRE(index->dataverse_name == dataverse_name);
             REQUIRE(index->dataset_name == dataset_name);
@@ -1748,7 +1757,7 @@ TEST_CASE("integration: analytics index management", "[integration]")
 }
 
 void
-run_s3_link_test(test::utils::integration_test_guard& integration, std::string dataverse_name, std::string link_name)
+run_s3_link_test(test::utils::integration_test_guard& integration, const std::string& dataverse_name, const std::string& link_name)
 {
     {
         couchbase::operations::management::analytics_dataverse_create_request req{};
@@ -1862,7 +1871,7 @@ run_s3_link_test(test::utils::integration_test_guard& integration, std::string d
 }
 
 void
-run_azure_link_test(test::utils::integration_test_guard& integration, std::string dataverse_name, std::string link_name)
+run_azure_link_test(test::utils::integration_test_guard& integration, const std::string& dataverse_name, const std::string& link_name)
 {
     {
         couchbase::operations::management::analytics_dataverse_create_request req{};
@@ -2600,7 +2609,7 @@ function OnDelete(meta, options) {
             auto resp = test::utils::execute(integration.cluster, req);
             REQUIRE_FALSE(resp.ctx.ec);
             auto function = std::find_if(
-              resp.functions.begin(), resp.functions.end(), [function_name](const auto& fun) { return function_name == fun.name; });
+              resp.functions.begin(), resp.functions.end(), [&function_name](const auto& fun) { return function_name == fun.name; });
             REQUIRE(function != resp.functions.end());
             REQUIRE(function->code == source_code);
             REQUIRE(function->source_keyspace.bucket == integration.ctx.bucket);
@@ -2627,7 +2636,7 @@ function OnDelete(meta, options) {
             auto resp = test::utils::execute(integration.cluster, req);
             REQUIRE_FALSE(resp.ctx.ec);
             REQUIRE(resp.status.num_eventing_nodes > 0);
-            auto function = std::find_if(resp.status.functions.begin(), resp.status.functions.end(), [function_name](const auto& fun) {
+            auto function = std::find_if(resp.status.functions.begin(), resp.status.functions.end(), [&function_name](const auto& fun) {
                 return function_name == fun.name;
             });
             REQUIRE(function != resp.status.functions.end());

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

@@ -80,7 +80,7 @@ TEST_CASE("integration: query on a collection", "[integration]")
         { "a", 1.0 },
         { "b", 2.0 },
     };
-    auto json = couchbase::utils::json::generate(value);
+    auto json = couchbase::utils::json::generate_binary(value);
 
     {
         couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
@@ -218,7 +218,7 @@ TEST_CASE("integration: preserve expiry for mutatation query", "[integration]")
     const char* expiry_path = "$document.exptime";
 
     {
-        couchbase::operations::upsert_request req{ id, R"({"foo":42})" };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(R"({"foo":42})") };
         req.expiry = expiry;
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);