couchbase 4.1.1 → 4.1.2

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/utils/unsigned_leb128.hxx

@@ -50,20 +50,20 @@ template<class T>
 typename std::enable_if_t<std::is_unsigned_v<T>, std::pair<T, std::string_view>>
 decode_unsigned_leb128(std::string_view buf, struct Leb128NoThrow /* unused */)
 {
-    T rv = static_cast<uint8_t>(buf[0]) & 0x7fULL;
+    T rv = static_cast<std::byte>(buf[0]) & std::byte{ 0b0111'1111 };
     size_t end = 0;
-    if ((static_cast<uint8_t>(buf[0]) & 0x80ULL) == 0x80ULL) {
+    if ((static_cast<std::byte>(buf[0]) & std::byte{ 0b1000'0000 }) == std::byte{ 0b1000'0000 }) {
         T shift = 7;
         // shift in the remaining data
         for (end = 1; end < buf.size(); end++) {
-            rv |= (static_cast<uint8_t>(buf[end]) & 0x7fULL) << shift;
-            if ((static_cast<uint8_t>(buf[end]) & 0x80ULL) == 0) {
+            rv |= (static_cast<std::byte>(buf[end]) & std::byte{ 0b0111'1111 }) << shift;
+            if ((static_cast<std::byte>(buf[end]) & std::byte{ 0b1000'0000 }) == std::byte{ 0 }) {
                 break; // no more
             }
             shift += 7;
         }
 
-        // We should of stopped for a stop byte, not the end of the buffer
+        // We should be stopped for a stop byte, not the end of the buffer
         if (end == buf.size()) {
             return { 0, std::string_view{} };
         }
@@ -87,7 +87,7 @@ template<class T>
 typename std::enable_if_t<std::is_unsigned_v<T>, std::pair<T, std::string_view>>
 decode_unsigned_leb128(std::string_view buf)
 {
-    if (buf.size() > 0) {
+    if (!buf.empty()) {
         auto rv = decode_unsigned_leb128<T>(buf, Leb128NoThrow());
         if (rv.second.data()) {
             return rv;
@@ -123,17 +123,17 @@ class unsigned_leb128<T, typename std::enable_if_t<std::is_unsigned_v<T>>>
     explicit unsigned_leb128(T in)
     {
         while (in > 0) {
-            auto byte = gsl::narrow_cast<uint8_t>(in & 0x7fULL);
+            auto byte = gsl::narrow_cast<std::byte>(in) & std::byte{ 0b0111'1111 };
             in >>= 7;
 
             // In has more data?
             if (in > 0) {
-                byte |= 0x80;
-                encodedData[encodedSize - 1U] = byte;
+                byte |= std::byte{ 0b1000'0000 };
+                encoded_data_[encoded_size_ - 1U] = byte;
                 // Increase the size
-                encodedSize++;
+                encoded_size_++;
             } else {
-                encodedData[encodedSize - 1U] = byte;
+                encoded_data_[encoded_size_ - 1U] = byte;
             }
         }
     }
@@ -143,29 +143,29 @@ class unsigned_leb128<T, typename std::enable_if_t<std::is_unsigned_v<T>>>
         return { begin(), end() };
     }
 
-    [[nodiscard]] const uint8_t* begin() const
+    [[nodiscard]] const std::byte* begin() const
     {
-        return encodedData.data();
+        return encoded_data_.data();
     }
 
-    [[nodiscard]] const uint8_t* end() const
+    [[nodiscard]] const std::byte* end() const
     {
-        return encodedData.data() + encodedSize;
+        return encoded_data_.data() + encoded_size_;
     }
 
-    [[nodiscard]] const uint8_t* data() const
+    [[nodiscard]] const std::byte* data() const
     {
-        return encodedData.data();
+        return encoded_data_.data();
     }
 
-    [[nodiscard]] size_t size() const
+    [[nodiscard]] std::size_t size() const
     {
-        return encodedSize;
+        return encoded_size_;
     }
 
-    constexpr static size_t getMaxSize()
+    constexpr static std::size_t get_max_size()
     {
-        return maxSize;
+        return max_size;
     }
 
   private:
@@ -173,9 +173,9 @@ class unsigned_leb128<T, typename std::enable_if_t<std::is_unsigned_v<T>>>
     static_assert(sizeof(T) <= 8, "Class is only valid for uint 8/16/64");
 
     // value is large enough to store ~0 as leb128
-    static constexpr size_t maxSize = sizeof(T) + (((sizeof(T) + 1) / 8) + 1);
-    std::array<uint8_t, maxSize> encodedData{};
-    uint8_t encodedSize{ 1 };
+    static constexpr std::size_t max_size = sizeof(T) + (((sizeof(T) + 1) / 8) + 1);
+    std::array<std::byte, max_size> encoded_data_{};
+    std::size_t encoded_size_{ 1 };
 };
 
 } // namespace couchbase::utils

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/utils/url_codec.cxx

@@ -68,7 +68,7 @@ template<typename T>
 inline bool
 is_already_escape(T first, T last)
 {
-    first++; // ignore '%'
+    ++first; // ignore '%'
     std::size_t jj = 0;
     for (; first != last && jj < 2; ++jj, ++first) {
         if (!isxdigit(*first)) {
@@ -148,12 +148,12 @@ url_decode(Ti first, Ti last, To out, std::size_t& nout)
         if (*first == '%') {
             char nextbuf[3] = { 0 };
             std::size_t jj = 0;
-            first++;
+            ++first;
             nextbuf[0] = *first;
             for (; first != last && jj < 2; ++jj) {
                 nextbuf[jj] = *first;
                 if (jj != 1) {
-                    first++;
+                    ++first;
                 }
             }
             if (jj != 2) {
@@ -171,7 +171,7 @@ url_decode(Ti first, Ti last, To out, std::size_t& nout)
             *out = *first;
         }
 
-        out++;
+        ++out;
         nout++;
     }
     return true;

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

@@ -10,6 +10,7 @@ integration_test(durability)
 integration_test(arithmetic)
 integration_test(collections)
 integration_test(subdoc)
+integration_test(analytics)
 
 unit_test(connection_string)
 unit_test(utils)

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/benchmark_integration_get.cxx

@@ -30,7 +30,7 @@ TEST_CASE("benchmark: get a document", "[benchmark]")
             { "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) };
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/test_integration_analytics.cxx

@@ -0,0 +1,260 @@
+/* -*- 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 "test_helper_integration.hxx"
+#include <couchbase/operations/management/analytics.hxx>
+#include <couchbase/operations/management/collection_create.hxx>
+#include <couchbase/operations/management/scope_create.hxx>
+
+TEST_CASE("integration: analytics query")
+{
+    test::utils::integration_test_guard integration;
+
+    if (!integration.cluster_version().supports_analytics()) {
+        return;
+    }
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    auto dataset_name = test::utils::uniq_id("dataset");
+
+    {
+        couchbase::operations::management::analytics_dataset_create_request req{};
+        req.dataset_name = dataset_name;
+        req.bucket_name = integration.ctx.bucket;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+    }
+
+    {
+        couchbase::operations::management::analytics_link_connect_request req{};
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+    }
+
+    auto key = test::utils::uniq_id("key");
+    auto test_value = test::utils::uniq_id("value");
+    auto value = couchbase::utils::json::generate({ { "testkey", test_value } });
+    {
+        auto id = couchbase::document_id(integration.ctx.bucket, "_default", "_default", key);
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(value) };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+    }
+
+    SECTION("simple query")
+    {
+        couchbase::operations::analytics_response resp{};
+        REQUIRE(test::utils::wait_until([&]() {
+            couchbase::operations::analytics_request req{};
+            req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value);
+            resp = test::utils::execute(integration.cluster, req);
+            return resp.rows.size() == 1;
+        }));
+        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE(resp.rows[0] == value);
+        REQUIRE_FALSE(resp.meta.request_id.empty());
+        REQUIRE_FALSE(resp.meta.client_context_id.empty());
+        REQUIRE_FALSE(resp.meta.status.empty());
+    }
+
+    SECTION("positional params")
+    {
+        couchbase::operations::analytics_response resp{};
+        REQUIRE(test::utils::wait_until([&]() {
+            couchbase::operations::analytics_request req{};
+            req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = ?)", dataset_name);
+            req.positional_parameters.emplace_back(couchbase::json_string(couchbase::utils::json::generate(test_value)));
+            resp = test::utils::execute(integration.cluster, req);
+            return resp.rows.size() == 1;
+        }));
+        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE(resp.rows[0] == value);
+    }
+
+    SECTION("named params")
+    {
+        couchbase::operations::analytics_response resp{};
+        REQUIRE(test::utils::wait_until([&]() {
+            couchbase::operations::analytics_request req{};
+            req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name);
+            req.named_parameters["testkey"] = couchbase::json_string(couchbase::utils::json::generate(test_value));
+            resp = test::utils::execute(integration.cluster, req);
+            return resp.rows.size() == 1;
+        }));
+        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE(resp.rows[0] == value);
+    }
+
+    SECTION("named params preformatted")
+    {
+        couchbase::operations::analytics_response resp{};
+        REQUIRE(test::utils::wait_until([&]() {
+            couchbase::operations::analytics_request req{};
+            req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name);
+            req.named_parameters["$testkey"] = couchbase::json_string(couchbase::utils::json::generate(test_value));
+            resp = test::utils::execute(integration.cluster, req);
+            return resp.rows.size() == 1;
+        }));
+        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE(resp.rows[0] == value);
+    }
+
+    SECTION("raw")
+    {
+        couchbase::operations::analytics_response resp{};
+        REQUIRE(test::utils::wait_until([&]() {
+            couchbase::operations::analytics_request req{};
+            req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name);
+            req.raw["$testkey"] = couchbase::json_string(couchbase::utils::json::generate(test_value));
+            resp = test::utils::execute(integration.cluster, req);
+            return resp.rows.size() == 1;
+        }));
+        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE(resp.rows[0] == value);
+    }
+
+    SECTION("consistency")
+    {
+        couchbase::operations::analytics_request req{};
+        req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value);
+        req.scan_consistency = couchbase::analytics_scan_consistency::request_plus;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE(resp.rows.size() == 1);
+        REQUIRE(resp.rows[0] == value);
+    }
+
+    SECTION("readonly")
+    {
+        couchbase::operations::analytics_request req{};
+        req.statement = fmt::format("DROP DATASET Default.`{}`", dataset_name);
+        req.readonly = true;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::internal_server_failure);
+    }
+
+    {
+        couchbase::operations::management::analytics_dataset_drop_request req{};
+        req.dataset_name = dataset_name;
+        test::utils::execute(integration.cluster, req);
+    }
+}
+
+TEST_CASE("integration: analytics scope query")
+{
+    test::utils::integration_test_guard integration;
+
+    if (!integration.cluster_version().supports_analytics() || !integration.cluster_version().supports_collections()) {
+        return;
+    }
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    auto scope_name = test::utils::uniq_id("scope");
+    auto collection_name = test::utils::uniq_id("collection");
+
+    {
+        couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
+    }
+
+    {
+        couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
+    }
+
+    {
+        couchbase::operations::analytics_request req{};
+        req.statement =
+          fmt::format("ALTER COLLECTION `{}`.`{}`.`{}` ENABLE ANALYTICS", integration.ctx.bucket, scope_name, collection_name);
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+    }
+
+    auto key = test::utils::uniq_id("key");
+    auto test_value = test::utils::uniq_id("value");
+    auto value = couchbase::utils::json::generate({ { "testkey", test_value } });
+    {
+        auto id = couchbase::document_id(integration.ctx.bucket, scope_name, collection_name, key);
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(value) };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+    }
+
+    couchbase::operations::analytics_response resp{};
+    REQUIRE(test::utils::wait_until([&]() {
+        couchbase::operations::analytics_request req{};
+        req.statement = fmt::format(R"(SELECT testkey FROM `{}` WHERE testkey = "{}")", collection_name, test_value);
+        req.bucket_name = integration.ctx.bucket;
+        req.scope_name = scope_name;
+        resp = test::utils::execute(integration.cluster, req);
+        return resp.rows.size() == 1;
+    }));
+    REQUIRE_FALSE(resp.ctx.ec);
+    REQUIRE(resp.rows[0] == value);
+
+    {
+        couchbase::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+        test::utils::execute(integration.cluster, req);
+    }
+}
+
+couchbase::http_context
+make_http_context()
+{
+    couchbase::topology::configuration config{};
+    couchbase::query_cache query_cache{};
+    couchbase::cluster_options cluster_options{};
+    std::string hostname{};
+    std::uint16_t port{};
+    couchbase::http_context ctx{ config, cluster_options, query_cache, hostname, port };
+    return ctx;
+}
+
+TEST_CASE("unit: analytics query")
+{
+    SECTION("priority true")
+    {
+        couchbase::io::http_request http_req;
+        auto ctx = make_http_context();
+        couchbase::operations::analytics_request req{};
+        req.priority = true;
+        auto ec = req.encode_to(http_req, ctx);
+        REQUIRE_FALSE(ec);
+        auto priority_header = http_req.headers.find("analytics-priority");
+        REQUIRE(priority_header != http_req.headers.end());
+        REQUIRE(priority_header->second == "-1");
+    }
+
+    SECTION("priority false")
+    {
+        couchbase::io::http_request http_req;
+        auto ctx = make_http_context();
+        couchbase::operations::analytics_request req{};
+        req.priority = false;
+        auto ec = req.encode_to(http_req, ctx);
+        REQUIRE_FALSE(ec);
+        REQUIRE(http_req.headers.find("analytics-priority") == http_req.headers.end());
+    }
+}

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/test_integration_arithmetic.cxx

@@ -27,7 +27,7 @@ TEST_CASE("integration: increment", "[integration]")
     SECTION("key exists")
     {
         {
-            couchbase::operations::insert_request req{ id, "0" };
+            couchbase::operations::insert_request req{ id, couchbase::utils::to_binary("0") };
             auto resp = test::utils::execute(integration.cluster, req);
             REQUIRE_FALSE(resp.ctx.ec);
         }
@@ -74,7 +74,7 @@ TEST_CASE("integration: decrement", "[integration]")
     SECTION("key exists")
     {
         {
-            couchbase::operations::insert_request req{ id, "20" };
+            couchbase::operations::insert_request req{ id, couchbase::utils::to_binary("20") };
             auto resp = test::utils::execute(integration.cluster, req);
             REQUIRE_FALSE(resp.ctx.ec);
         }

package/deps/couchbase-transactions-cxx/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-transactions-cxx/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);
@@ -89,22 +89,20 @@ TEST_CASE("integration: get and insert non default scope and collection", "[inte
         couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
     }
 
-    std::uint64_t current_manifest_uid = 0;
     {
         couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        current_manifest_uid = resp.uid;
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
     }
 
-    auto created =
-      test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, current_manifest_uid);
-    REQUIRE(created);
-
     {
-        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);
     }
@@ -113,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));
     }
 }
 
@@ -148,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);
     }
@@ -157,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));
     }
 
     {
@@ -169,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-transactions-cxx/deps/couchbase-cxx-client/test/test_integration_connect.cxx

@@ -42,6 +42,10 @@ TEST_CASE("integration: connecting with unresponsive first node in bootstrap nod
     test::utils::init_logger();
     asio::io_context io{};
     auto ctx = test::utils::test_context::load_from_environment();
+    if (ctx.deployment == test::utils::deployment_type::capella) {
+        // This breaks SRV assumptions (only one host in connection string)
+        return;
+    }
     auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
     REQUIRE_FALSE(connstr.bootstrap_nodes.empty());
     connstr.bootstrap_nodes.insert(connstr.bootstrap_nodes.begin(),
@@ -127,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);
     }