couchbase 4.1.1 → 4.1.3

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

@@ -17,96 +17,195 @@
 
 #include "test_helper_integration.hxx"
 
+#include <couchbase/cluster.hxx>
+#include <couchbase/codec/raw_binary_transcoder.hxx>
+
 TEST_CASE("integration: increment", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("counter") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("counter") };
 
     SECTION("key exists")
     {
         {
-            couchbase::operations::insert_request req{ id, "0" };
+            couchbase::core::operations::insert_request req{ id, couchbase::core::utils::to_binary("0") };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
         }
 
         for (uint64_t expected = 2; expected <= 20; expected += 2) {
-            couchbase::operations::increment_request req{ id };
+            couchbase::core::operations::increment_request req{ id };
             req.delta = 2;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
             REQUIRE(resp.content == expected);
         }
     }
 
     SECTION("initial value")
     {
-        couchbase::operations::increment_request req{ id };
+        couchbase::core::operations::increment_request req{ id };
         req.delta = 2;
         req.initial_value = 10;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE(resp.content == 10);
     }
 
     if (integration.cluster_version().supports_enhanced_durability()) {
         SECTION("durability")
         {
-            couchbase::operations::increment_request req{ id };
+            couchbase::core::operations::increment_request req{ id };
             req.initial_value = 2;
-            req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
+            req.durability_level = couchbase::durability_level::persist_to_majority;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
             REQUIRE(resp.content == 2);
         }
     }
 }
 
+TEST_CASE("integration: increment with public API", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    auto collection = couchbase::cluster(integration.cluster)
+                        .bucket(integration.ctx.bucket)
+                        .scope(couchbase::scope::default_name)
+                        .collection(couchbase::collection::default_name);
+
+    auto id = test::utils::uniq_id("counter");
+
+    SECTION("key exists")
+    {
+        {
+            const auto ascii_zero = couchbase::core::utils::to_binary("0");
+            auto [ctx, resp] = collection.insert<couchbase::codec::raw_binary_transcoder>(id, ascii_zero, {}).get();
+            REQUIRE_FALSE(ctx.ec());
+            REQUIRE_FALSE(resp.cas().empty());
+        }
+
+        for (uint64_t expected = 2; expected <= 20; expected += 2) {
+            auto [ctx, resp] = collection.binary().increment(id, couchbase::increment_options{}.delta(2)).get();
+            REQUIRE_FALSE(ctx.ec());
+            REQUIRE(resp.content() == expected);
+        }
+    }
+
+    SECTION("initial value")
+    {
+        auto [ctx, resp] = collection.binary().increment(id, couchbase::increment_options{}.delta(2).initial(10)).get();
+        REQUIRE_FALSE(ctx.ec());
+        REQUIRE(resp.content() == 10);
+    }
+
+    if (integration.cluster_version().supports_enhanced_durability()) {
+        SECTION("durability")
+        {
+            auto [ctx, resp] =
+              collection.binary()
+                .increment(id, couchbase::increment_options{}.initial(2).durability(couchbase::durability_level::persist_to_majority))
+                .get();
+            REQUIRE_FALSE(ctx.ec());
+            REQUIRE(resp.content() == 2);
+        }
+    }
+}
+
 TEST_CASE("integration: decrement", "[integration]")
 {
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("counter") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("counter") };
 
     SECTION("key exists")
     {
         {
-            couchbase::operations::insert_request req{ id, "20" };
+            couchbase::core::operations::insert_request req{ id, couchbase::core::utils::to_binary("20") };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
         }
 
         for (uint64_t expected = 18; expected > 0; expected -= 2) {
-            couchbase::operations::decrement_request req{ id };
+            couchbase::core::operations::decrement_request req{ id };
             req.delta = 2;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
             REQUIRE(resp.content == expected);
         }
     }
 
     SECTION("initial value")
     {
-        couchbase::operations::decrement_request req{ id };
+        couchbase::core::operations::decrement_request req{ id };
         req.delta = 2;
         req.initial_value = 10;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE(resp.content == 10);
     }
 
     if (integration.cluster_version().supports_enhanced_durability()) {
         SECTION("durability")
         {
-            couchbase::operations::decrement_request req{ id };
+            couchbase::core::operations::decrement_request req{ id };
             req.initial_value = 2;
-            req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
+            req.durability_level = couchbase::durability_level::persist_to_majority;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
             REQUIRE(resp.content == 2);
         }
     }
 }
+
+TEST_CASE("integration: decrement with public API", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    auto collection = couchbase::cluster(integration.cluster)
+                        .bucket(integration.ctx.bucket)
+                        .scope(couchbase::scope::default_name)
+                        .collection(couchbase::collection::default_name);
+
+    auto id = test::utils::uniq_id("counter");
+
+    SECTION("key exists")
+    {
+        {
+            const auto ascii_twenty = couchbase::core::utils::to_binary("20");
+            auto [ctx, resp] = collection.insert<couchbase::codec::raw_binary_transcoder>(id, ascii_twenty, {}).get();
+            REQUIRE_FALSE(ctx.ec());
+            REQUIRE_FALSE(resp.cas().empty());
+        }
+
+        for (uint64_t expected = 18; expected > 0; expected -= 2) {
+            auto [ctx, resp] = collection.binary().decrement(id, couchbase::decrement_options{}.delta(2)).get();
+            REQUIRE_FALSE(ctx.ec());
+            REQUIRE(resp.content() == expected);
+        }
+    }
+
+    SECTION("initial value")
+    {
+        auto [ctx, resp] = collection.binary().decrement(id, couchbase::decrement_options{}.delta(2).initial(10)).get();
+        REQUIRE_FALSE(ctx.ec());
+        REQUIRE(resp.content() == 10);
+    }
+
+    if (integration.cluster_version().supports_enhanced_durability()) {
+        SECTION("durability")
+        {
+            auto [ctx, resp] =
+              collection.binary()
+                .decrement(id, couchbase::decrement_options{}.initial(2).durability(couchbase::durability_level::persist_to_majority))
+                .get();
+            REQUIRE_FALSE(ctx.ec());
+            REQUIRE(resp.content() == 2);
+        }
+    }
+}

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

@@ -17,7 +17,7 @@
 
 #include "test_helper_integration.hxx"
 
-#include <couchbase/cas_fmt.hxx>
+#include "core/utils/binary.hxx"
 
 TEST_CASE("integration: append", "[integration]")
 {
@@ -25,34 +25,30 @@ TEST_CASE("integration: append", "[integration]")
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
     {
-        couchbase::operations::upsert_request req{ id, "world" };
+        couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::to_binary("world") };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
-        INFO("cas=" << fmt::to_string(resp.cas))
+        INFO(resp.ctx.ec().message())
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        INFO("seqno=" << resp.token.sequence_number)
-        REQUIRE(resp.token.sequence_number != 0);
+        REQUIRE(resp.token.sequence_number() != 0);
     }
     {
-        couchbase::operations::append_request req{ id, "!" };
+        couchbase::core::operations::append_request req{ id, couchbase::core::utils::to_binary("!") };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        INFO(resp.ctx.ec().message())
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        INFO("seqno=" << resp.token.sequence_number)
-        REQUIRE(resp.token.sequence_number != 0);
+        REQUIRE(resp.token.sequence_number() != 0);
     }
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        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::core::utils::to_binary("world!"));
     }
 }
 
@@ -62,33 +58,30 @@ TEST_CASE("integration: prepend", "[integration]")
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
     {
-        couchbase::operations::upsert_request req{ id, "world" };
+        couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::to_binary("world") };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        INFO(resp.ctx.ec().message())
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        INFO("seqno=" << resp.token.sequence_number)
-        REQUIRE(resp.token.sequence_number != 0);
+        REQUIRE(resp.token.sequence_number() != 0);
     }
     {
-        couchbase::operations::prepend_request req{ id, "Hello, " };
+        couchbase::core::operations::prepend_request req{ id, couchbase::core::utils::to_binary("Hello, ") };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        INFO(resp.ctx.ec().message())
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        INFO("seqno=" << resp.token.sequence_number)
-        REQUIRE(resp.token.sequence_number != 0);
+        REQUIRE(resp.token.sequence_number() != 0);
     }
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        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::core::utils::to_binary("Hello, world"));
     }
 }
 
@@ -97,19 +90,19 @@ TEST_CASE("integration: binary ops on missing document", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", "missing_key" };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", "missing_key" };
 
     SECTION("append")
     {
-        couchbase::operations::append_request req{ id, "" };
+        couchbase::core::operations::append_request req{ id, couchbase::core::utils::to_binary("") };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
     }
 
     SECTION("prepend")
     {
-        couchbase::operations::prepend_request req{ id, "" };
+        couchbase::core::operations::prepend_request req{ id, couchbase::core::utils::to_binary("") };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
     }
 }

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

@@ -17,7 +17,7 @@
 
 #include "test_helper_integration.hxx"
 
-#include <couchbase/operations/management/collections.hxx>
+#include "core/operations/management/collections.hxx"
 
 TEST_CASE("integration: missing scope and collection", "[integration]")
 {
@@ -30,44 +30,44 @@ TEST_CASE("integration: missing scope and collection", "[integration]")
 
     SECTION("get missing scope")
     {
-        couchbase::document_id id{ integration.ctx.bucket, "missing_scope", "_default", "key" };
-        couchbase::operations::get_request req{ id };
+        couchbase::core::document_id id{ integration.ctx.bucket, "missing_scope", "_default", "key" };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::scope_not_found);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::common::scope_not_found);
     }
 
     SECTION("insert missing scope")
     {
-        couchbase::document_id id{ integration.ctx.bucket, "missing_scope", "_default", "key" };
+        couchbase::core::document_id id{ integration.ctx.bucket, "missing_scope", "_default", "key" };
         const tao::json::value value = {
             { "a", 1.0 },
             { "b", 2.0 },
         };
-        couchbase::operations::insert_request req{ id, couchbase::utils::json::generate(value) };
+        couchbase::core::operations::insert_request req{ id, couchbase::core::utils::json::generate_binary(value) };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::scope_not_found);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::common::scope_not_found);
     }
 
     SECTION("get missing collection")
     {
-        couchbase::document_id id{ integration.ctx.bucket, "_default", "missing_collection", "key" };
-        couchbase::operations::get_request req{ id };
+        couchbase::core::document_id id{ integration.ctx.bucket, "_default", "missing_collection", "key" };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::unambiguous_timeout);
-        REQUIRE(resp.ctx.retry_reasons.count(couchbase::io::retry_reason::kv_collection_outdated) == 1);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::common::unambiguous_timeout);
+        REQUIRE(resp.ctx.retried_because_of(couchbase::retry_reason::kv_collection_outdated));
     }
 
     SECTION("insert missing collection")
     {
-        couchbase::document_id id{ integration.ctx.bucket, "_default", "missing_collection", "key" };
+        couchbase::core::document_id id{ integration.ctx.bucket, "_default", "missing_collection", "key" };
         const tao::json::value value = {
             { "a", 1.0 },
             { "b", 2.0 },
         };
-        couchbase::operations::insert_request req{ id, couchbase::utils::json::generate(value) };
+        couchbase::core::operations::insert_request req{ id, couchbase::core::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);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::common::ambiguous_timeout);
+        REQUIRE(resp.ctx.retried_because_of(couchbase::retry_reason::kv_collection_outdated));
     }
 }
 
@@ -83,37 +83,35 @@ TEST_CASE("integration: get and insert non default scope and collection", "[inte
     auto scope_name = test::utils::uniq_id("scope");
     auto collection_name = test::utils::uniq_id("scope");
     auto key = test::utils::uniq_id("foo");
-    auto id = couchbase::document_id{ integration.ctx.bucket, scope_name, collection_name, key };
+    auto id = couchbase::core::document_id{ integration.ctx.bucket, scope_name, collection_name, key };
 
     {
-        couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+        couchbase::core::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 };
+        couchbase::core::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::core::operations::insert_request req{ id, couchbase::core::utils::to_binary(key) };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == key);
+        REQUIRE_FALSE(resp.ctx.ec());
+        REQUIRE(resp.value == couchbase::core::utils::to_binary(key));
     }
 }
 
@@ -129,10 +127,10 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
     auto scope_name = test::utils::uniq_id("scope");
     auto collection_name = test::utils::uniq_id("scope");
     auto key = test::utils::uniq_id("foo");
-    auto id = couchbase::document_id{ integration.ctx.bucket, scope_name, collection_name, key };
+    auto id = couchbase::core::document_id{ integration.ctx.bucket, scope_name, collection_name, key };
 
     {
-        couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+        couchbase::core::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);
@@ -140,7 +138,7 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
     }
 
     {
-        couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
+        couchbase::core::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);
@@ -148,20 +146,20 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
     }
 
     {
-        couchbase::operations::insert_request req{ id, key };
+        couchbase::core::operations::insert_request req{ id, couchbase::core::utils::to_binary(key) };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == key);
+        REQUIRE_FALSE(resp.ctx.ec());
+        REQUIRE(resp.value == couchbase::core::utils::to_binary(key));
     }
 
     {
-        couchbase::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+        couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
         auto dropped = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
@@ -169,8 +167,8 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
     }
 
     {
-        couchbase::operations::upsert_request req{ id, key };
+        couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::to_binary(key) };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::scope_not_found);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::common::scope_not_found);
     }
 }

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

@@ -23,16 +23,16 @@
 TEST_CASE("integration: connecting with empty bootstrap nodes list", "[integration]")
 {
     asio::io_context io{};
-    auto connstr = couchbase::utils::parse_connection_string("couchbase://");
+    auto connstr = couchbase::core::utils::parse_connection_string("couchbase://");
     REQUIRE(connstr.bootstrap_nodes.empty());
-    auto origin = couchbase::origin({}, connstr);
-    auto cluster = couchbase::cluster::create(io);
+    auto origin = couchbase::core::origin({}, connstr);
+    auto cluster = couchbase::core::cluster::create(io);
     auto io_thread = std::thread([&io]() { io.run(); });
     auto barrier = std::make_shared<std::promise<std::error_code>>();
     auto f = barrier->get_future();
     cluster->open(origin, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
     auto rc = f.get();
-    REQUIRE(rc == couchbase::error::common_errc::invalid_argument);
+    REQUIRE(rc == couchbase::errc::common::invalid_argument);
     test::utils::close_cluster(cluster);
     io_thread.join();
 }
@@ -42,17 +42,21 @@ 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();
-    auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
+    if (ctx.deployment == test::utils::deployment_type::capella) {
+        // This breaks SRV assumptions (only one host in connection string)
+        return;
+    }
+    auto connstr = couchbase::core::utils::parse_connection_string(ctx.connection_string);
     REQUIRE_FALSE(connstr.bootstrap_nodes.empty());
     connstr.bootstrap_nodes.insert(connstr.bootstrap_nodes.begin(),
-                                   couchbase::utils::connection_string::node{
+                                   couchbase::core::utils::connection_string::node{
                                      "example.com",
                                      11210,
-                                     couchbase::utils::connection_string::address_type::dns,
-                                     couchbase::utils::connection_string::bootstrap_mode::gcccp,
+                                     couchbase::core::utils::connection_string::address_type::dns,
+                                     couchbase::core::utils::connection_string::bootstrap_mode::gcccp,
                                    });
-    auto origin = couchbase::origin(ctx.build_auth(), connstr);
-    auto cluster = couchbase::cluster::create(io);
+    auto origin = couchbase::core::origin(ctx.build_auth(), connstr);
+    auto cluster = couchbase::core::cluster::create(io);
     auto io_thread = std::thread([&io]() { io.run(); });
     auto barrier = std::make_shared<std::promise<std::error_code>>();
     auto f = barrier->get_future();
@@ -67,7 +71,7 @@ TEST_CASE("integration: can connect with handler capturing non-copyable object",
 {
     test::utils::integration_test_guard integration;
 
-    auto cluster = couchbase::cluster::create(integration.io);
+    auto cluster = couchbase::core::cluster::create(integration.io);
 
     // test connecting
     {
@@ -117,24 +121,24 @@ TEST_CASE("integration: destroy cluster without waiting for close completion", "
 
     asio::io_context io{};
 
-    auto cluster = couchbase::cluster::create(io);
+    auto cluster = couchbase::core::cluster::create(io);
     auto io_thread = std::thread([&io]() { io.run(); });
 
-    auto origin = couchbase::origin(ctx.build_auth(), couchbase::utils::parse_connection_string(ctx.connection_string));
+    auto origin = couchbase::core::origin(ctx.build_auth(), couchbase::core::utils::parse_connection_string(ctx.connection_string));
     test::utils::open_cluster(cluster, origin);
     test::utils::open_bucket(cluster, ctx.bucket);
 
     // hit KV
     {
-        couchbase::document_id id{ ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
-        couchbase::operations::upsert_request req{ id, "{{}}" };
+        couchbase::core::document_id id{ ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
+        couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::to_binary("{{}}") };
         auto resp = test::utils::execute(cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     // hit Query
     {
-        couchbase::operations::query_request req{ R"(SELECT 42 AS the_answer)" };
+        couchbase::core::operations::query_request req{ R"(SELECT 42 AS the_answer)" };
         auto resp = test::utils::execute(cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
     }