couchbase 4.2.2 → 4.2.4

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

@@ -17,15 +17,19 @@
 
 #include "core/operations/management/analytics.hxx"
 #include "core/operations/management/collection_create.hxx"
-#include "core/operations/management/scope_create.hxx"
+#include "core/operations/management/collections.hxx"
 #include "test_helper_integration.hxx"
 
 TEST_CASE("integration: analytics query")
 {
     test::utils::integration_test_guard integration;
 
+    if (integration.ctx.deployment == test::utils::deployment_type::elixir) {
+        SKIP("elixir deployment does not support analytics");
+    }
+
     if (!integration.cluster_version().supports_analytics()) {
-        return;
+        SKIP("cluster does not support analytics");
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -78,7 +82,7 @@ TEST_CASE("integration: analytics query")
         REQUIRE(test::utils::wait_until([&]() {
             couchbase::core::operations::analytics_request req{};
             req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = ?)", dataset_name);
-            req.positional_parameters.emplace_back(couchbase::core::json_string(couchbase::core::utils::json::generate(test_value)));
+            req.positional_parameters.emplace_back(couchbase::core::utils::json::generate(test_value));
             resp = test::utils::execute(integration.cluster, req);
             return resp.rows.size() == 1;
         }));
@@ -130,10 +134,30 @@ TEST_CASE("integration: analytics query")
 
     SECTION("consistency")
     {
-        couchbase::core::operations::analytics_request req{};
-        req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value);
-        req.scan_consistency = couchbase::core::analytics_scan_consistency::request_plus;
-        auto resp = test::utils::execute(integration.cluster, req);
+        couchbase::core::operations::analytics_response resp{};
+        CHECK(test::utils::wait_until([&]() {
+            /*
+             * In consistency test, always do fresh mutation
+             */
+            test_value = test::utils::uniq_id("value");
+            value = couchbase::core::utils::json::generate({ { "testkey", test_value } });
+            {
+                auto id = couchbase::core::document_id(integration.ctx.bucket, "_default", "_default", key);
+                couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::to_binary(value) };
+                REQUIRE_SUCCESS(test::utils::execute(integration.cluster, req).ctx.ec());
+            }
+
+            couchbase::core::operations::analytics_request req{};
+            req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value);
+            req.scan_consistency = couchbase::core::analytics_scan_consistency::request_plus;
+            resp = test::utils::execute(integration.cluster, req);
+            /* Analytics might give us code 23027, ignore it here
+             *
+             * "errors": [{"code": 23027, "msg": "Bucket default on link Default.Local is not connected"} ],
+             */
+            return resp.ctx.first_error_code != 23027;
+        }));
+
         REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.rows.size() == 1);
         REQUIRE(resp.rows[0] == value);
@@ -160,8 +184,15 @@ TEST_CASE("integration: analytics scope query")
 {
     test::utils::integration_test_guard integration;
 
-    if (!integration.cluster_version().supports_analytics() || !integration.cluster_version().supports_collections()) {
-        return;
+    if (integration.ctx.deployment == test::utils::deployment_type::elixir) {
+        SKIP("elixir deployment does not support analytics");
+    }
+
+    if (!integration.cluster_version().supports_analytics()) {
+        SKIP("cluster does not support analytics");
+    }
+    if (!integration.cluster_version().supports_collections()) {
+        SKIP("cluster does not support collections");
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -185,13 +216,15 @@ TEST_CASE("integration: analytics scope query")
         REQUIRE(created);
     }
 
-    {
-        couchbase::core::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_SUCCESS(resp.ctx.ec);
-    }
+    CHECK(test::utils::wait_until(
+      [&]() {
+          couchbase::core::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);
+          return !resp.ctx.ec;
+      },
+      std::chrono::minutes{ 5 }));
 
     auto key = test::utils::uniq_id("key");
     auto test_value = test::utils::uniq_id("value");
@@ -259,3 +292,268 @@ TEST_CASE("unit: analytics query")
         REQUIRE(http_req.headers.find("analytics-priority") == http_req.headers.end());
     }
 }
+
+TEST_CASE("integration: public API analytics query")
+{
+    test::utils::integration_test_guard integration;
+
+    if (integration.ctx.deployment == test::utils::deployment_type::elixir) {
+        SKIP("elixir deployment does not support analytics");
+    }
+
+    if (!integration.cluster_version().supports_analytics()) {
+        SKIP("cluster does not support analytics");
+    }
+
+    auto cluster = couchbase::cluster(integration.cluster);
+    auto bucket = cluster.bucket(integration.ctx.bucket);
+    auto collection = bucket.default_collection();
+
+    auto dataset_name = test::utils::uniq_id("dataset");
+
+    {
+        couchbase::core::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_SUCCESS(resp.ctx.ec);
+    }
+
+    {
+        couchbase::core::operations::management::analytics_link_connect_request req{};
+        req.force = true;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+    }
+
+    auto key = test::utils::uniq_id("key");
+    auto test_value = test::utils::uniq_id("value");
+    tao::json::value document = {
+        { "testkey", test_value },
+    };
+    {
+        auto [ctx, resp] = collection.upsert(key, document).get();
+        REQUIRE_SUCCESS(ctx.ec());
+    }
+
+    SECTION("simple query")
+    {
+        couchbase::analytics_result resp{};
+        couchbase::analytics_error_context ctx{};
+        CHECK(test::utils::wait_until([&]() {
+            std::tie(ctx, resp) =
+              cluster.analytics_query(fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value))
+                .get();
+            return !ctx.ec() && resp.meta_data().metrics().result_count() == 1;
+        }));
+        REQUIRE_SUCCESS(ctx.ec());
+        REQUIRE_FALSE(resp.meta_data().request_id().empty());
+        REQUIRE_FALSE(resp.meta_data().client_context_id().empty());
+        REQUIRE(resp.meta_data().status() == couchbase::analytics_status::success);
+        auto rows = resp.rows_as_json();
+        REQUIRE(rows.size() == 1);
+        REQUIRE(rows[0] == document);
+    }
+
+    SECTION("positional params")
+    {
+        couchbase::analytics_result resp{};
+        couchbase::analytics_error_context ctx{};
+        CHECK(test::utils::wait_until([&]() {
+            std::tie(ctx, resp) = cluster
+                                    .analytics_query(fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = ?)", dataset_name),
+                                                     couchbase::analytics_options{}.positional_parameters(test_value))
+                                    .get();
+            return !ctx.ec() && resp.meta_data().metrics().result_count() == 1;
+        }));
+        REQUIRE_SUCCESS(ctx.ec());
+        auto rows = resp.rows_as_json();
+        REQUIRE(rows.size() == 1);
+        REQUIRE(rows[0] == document);
+    }
+
+    SECTION("named params")
+    {
+        couchbase::analytics_result resp{};
+        couchbase::analytics_error_context ctx{};
+        CHECK(test::utils::wait_until([&]() {
+            std::tie(ctx, resp) =
+              cluster
+                .analytics_query(fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name),
+                                 couchbase::analytics_options{}.named_parameters(std::pair{ "testkey", test_value }))
+                .get();
+            return !ctx.ec() && resp.meta_data().metrics().result_count() == 1;
+        }));
+        REQUIRE_SUCCESS(ctx.ec());
+        auto rows = resp.rows_as_json();
+        REQUIRE(rows.size() == 1);
+        REQUIRE(rows[0] == document);
+    }
+
+    SECTION("named params preformatted")
+    {
+        couchbase::analytics_result resp{};
+        couchbase::analytics_error_context ctx{};
+        CHECK(test::utils::wait_until([&]() {
+            std::tie(ctx, resp) =
+              cluster
+                .analytics_query(fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name),
+                                 couchbase::analytics_options{}.encoded_named_parameters(
+                                   { { "testkey", couchbase::core::utils::json::generate_binary(test_value) } }))
+                .get();
+            return !ctx.ec() && resp.meta_data().metrics().result_count() == 1;
+        }));
+        REQUIRE_SUCCESS(ctx.ec());
+        auto rows = resp.rows_as_json();
+        REQUIRE(rows.size() == 1);
+        REQUIRE(rows[0] == document);
+    }
+
+    SECTION("raw")
+    {
+        couchbase::analytics_result resp{};
+        couchbase::analytics_error_context ctx{};
+        CHECK(test::utils::wait_until([&]() {
+            std::tie(ctx, resp) =
+              cluster
+                .analytics_query(fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name),
+                                 couchbase::analytics_options{}.raw("$testkey", test_value))
+                .get();
+            return !ctx.ec() && resp.meta_data().metrics().result_count() == 1;
+        }));
+        REQUIRE_SUCCESS(ctx.ec());
+        auto rows = resp.rows_as_json();
+        REQUIRE(rows.size() == 1);
+        REQUIRE(rows[0] == document);
+    }
+
+    SECTION("consistency")
+    {
+        couchbase::analytics_result resp{};
+        couchbase::analytics_error_context ctx{};
+        CHECK(test::utils::wait_until([&]() {
+            /*
+             * In consistency test, always do fresh mutation
+             */
+            test_value = test::utils::uniq_id("value");
+            document = {
+                { "testkey", test_value },
+            };
+            {
+                auto [ctx2, _] = collection.upsert(key, document).get();
+                REQUIRE_SUCCESS(ctx2.ec());
+            }
+
+            std::tie(ctx, resp) =
+              cluster
+                .analytics_query(fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value),
+                                 couchbase::analytics_options{}.scan_consistency(couchbase::analytics_scan_consistency::request_plus))
+                .get();
+            /* Analytics might give us code 23027, ignore it here
+             *
+             * "errors": [{"code": 23027, "msg": "Bucket default on link Default.Local is not connected"} ],
+             */
+            return ctx.first_error_code() != 23027;
+        }));
+
+        REQUIRE_SUCCESS(ctx.ec());
+        auto rows = resp.rows_as_json();
+        REQUIRE(rows.size() == 1);
+        REQUIRE(rows[0] == document);
+    }
+
+    SECTION("readonly")
+    {
+        auto [ctx, resp] =
+          cluster.analytics_query(fmt::format("DROP DATASET Default.`{}`", dataset_name), couchbase::analytics_options{}.readonly(true))
+            .get();
+
+        REQUIRE(ctx.ec() == couchbase::errc::common::internal_server_failure);
+        REQUIRE(resp.meta_data().status() == couchbase::analytics_status::fatal);
+    }
+
+    {
+        couchbase::core::operations::management::analytics_dataset_drop_request req{};
+        req.dataset_name = dataset_name;
+        test::utils::execute(integration.cluster, req);
+    }
+}
+
+TEST_CASE("integration: public API analytics scope query")
+{
+    test::utils::integration_test_guard integration;
+
+    if (integration.ctx.deployment == test::utils::deployment_type::elixir) {
+        SKIP("elixir deployment does not support analytics");
+    }
+
+    if (!integration.cluster_version().supports_analytics()) {
+        SKIP("cluster does not support analytics");
+    }
+    if (!integration.cluster_version().supports_collections()) {
+        SKIP("cluster does not support collections");
+    }
+
+    auto cluster = couchbase::cluster(integration.cluster);
+    auto bucket = cluster.bucket(integration.ctx.bucket);
+
+    auto scope_name = test::utils::uniq_id("scope");
+    auto collection_name = test::utils::uniq_id("collection");
+
+    {
+        const couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
+    }
+
+    {
+        const couchbase::core::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
+    }
+
+    CHECK(test::utils::wait_until(
+      [&]() {
+          auto [ctx, resp] = cluster
+                               .analytics_query(fmt::format(
+                                 "ALTER COLLECTION `{}`.`{}`.`{}` ENABLE ANALYTICS", integration.ctx.bucket, scope_name, collection_name))
+                               .get();
+          return !ctx.ec();
+      },
+      std::chrono::minutes{ 5 }));
+
+    auto scope = bucket.scope(scope_name);
+    auto collection = scope.collection(collection_name);
+
+    auto key = test::utils::uniq_id("key");
+    auto test_value = test::utils::uniq_id("value");
+    const tao::json::value document = {
+        { "testkey", test_value },
+    };
+    {
+        auto [ctx, resp] = collection.upsert(key, document).get();
+        REQUIRE_SUCCESS(ctx.ec());
+    }
+
+    couchbase::analytics_result resp{};
+    couchbase::analytics_error_context ctx{};
+    CHECK(test::utils::wait_until([&]() {
+        std::tie(ctx, resp) =
+          scope.analytics_query(fmt::format(R"(SELECT testkey FROM `{}` WHERE testkey = "{}")", collection_name, test_value)).get();
+        return !ctx.ec() && resp.meta_data().metrics().result_count() == 1;
+    }));
+    REQUIRE_SUCCESS(ctx.ec());
+    REQUIRE(resp.rows_as_json()[0] == document);
+    REQUIRE_FALSE(resp.meta_data().request_id().empty());
+    REQUIRE_FALSE(resp.meta_data().client_context_id().empty());
+    REQUIRE(resp.meta_data().status() == couchbase::analytics_status::success);
+
+    {
+        const couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+        test::utils::execute(integration.cluster, req);
+    }
+}

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

@@ -25,7 +25,7 @@ TEST_CASE("integration: missing scope and collection", "[integration]")
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
 
     SECTION("get missing scope")
@@ -77,7 +77,7 @@ TEST_CASE("integration: get and insert non default scope and collection", "[inte
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
 
     auto scope_name = test::utils::uniq_id("scope");
@@ -121,7 +121,7 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
 
     auto scope_name = test::utils::uniq_id("scope");
@@ -166,6 +166,10 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
         REQUIRE(dropped);
     }
 
+    if (integration.cluster_version().is_mock()) {
+        SKIP("GOCAVES does not generate error when inserting into dropped collection. See "
+             "https://github.com/couchbaselabs/gocaves/issues/108");
+    }
     {
         couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::to_binary(key) };
         auto resp = test::utils::execute(integration.cluster, req);

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

@@ -42,9 +42,9 @@ 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) {
+    if (ctx.deployment == test::utils::deployment_type::capella || ctx.deployment == test::utils::deployment_type::elixir) {
         // This breaks SRV assumptions (only one host in connection string)
-        return;
+        SKIP("capella deployment uses single host in the connection string, which assumed to be reachable");
     }
     auto connstr = couchbase::core::utils::parse_connection_string(ctx.connection_string);
     REQUIRE_FALSE(connstr.bootstrap_nodes.empty());
@@ -125,6 +125,10 @@ TEST_CASE("integration: destroy cluster without waiting for close completion", "
     test::utils::init_logger();
     auto ctx = test::utils::test_context::load_from_environment();
 
+    if (ctx.deployment == test::utils::deployment_type::elixir) {
+        SKIP("elixir deployment is incompatible with parts of this test, but it is probably bug in SDK. FIXME");
+    }
+
     asio::io_context io{};
 
     auto cluster = couchbase::core::cluster::create(io);
@@ -143,7 +147,7 @@ TEST_CASE("integration: destroy cluster without waiting for close completion", "
     }
 
     // hit Query
-    {
+    if (ctx.version.supports_query()) {
         couchbase::core::operations::query_request req{ R"(SELECT 42 AS the_answer)" };
         auto resp = test::utils::execute(cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec);

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

@@ -35,6 +35,10 @@ TEST_CASE("integration: switching off mutation token", "[integration]")
     opts.enable_mutation_tokens = false;
     test::utils::integration_test_guard integration(opts);
 
+    if (integration.cluster_version().is_mock()) {
+        SKIP("GOCAVES does not allow to switching off mutation tokens. See https://github.com/couchbaselabs/gocaves/issues/100");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
 
@@ -228,6 +232,10 @@ TEST_CASE("integration: pessimistic locking", "[integration]")
     {
         couchbase::core::operations::get_and_lock_request req{ id };
         req.lock_time = lock_time;
+        if (integration.ctx.deployment == test::utils::deployment_type::capella ||
+            integration.ctx.deployment == test::utils::deployment_type::elixir) {
+            req.timeout = std::chrono::seconds{ 2 };
+        }
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec() == couchbase::errc::common::ambiguous_timeout);
         REQUIRE(resp.ctx.retried_because_of(couchbase::retry_reason::key_value_locked));
@@ -486,7 +494,7 @@ TEST_CASE("integration: upsert preserve expiry", "[integration]")
     test::utils::integration_test_guard integration;
 
     if (!integration.cluster_version().supports_preserve_expiry()) {
-        return;
+        SKIP("cluster does not support preserve expiry");
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -667,6 +675,10 @@ TEST_CASE("integration: open bucket that does not exist", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (integration.cluster_version().is_mock()) {
+        SKIP("GOCAVES returns not_found (0x01) instead of no_access (0x24). See https://github.com/couchbaselabs/gocaves/issues/102");
+    }
+
     auto bucket_name = test::utils::uniq_id("missing_bucket");
 
     auto barrier = std::make_shared<std::promise<std::error_code>>();
@@ -810,7 +822,12 @@ TEST_CASE("integration: pessimistic locking with public API", "[integration]")
 
     // it is not allowed to lock the same key twice
     {
-        auto [ctx, resp] = collection.get_and_lock(id, lock_time, {}).get();
+        couchbase::get_and_lock_options options{};
+        if (integration.ctx.deployment == test::utils::deployment_type::capella ||
+            integration.ctx.deployment == test::utils::deployment_type::elixir) {
+            options.timeout(std::chrono::seconds{ 2 });
+        }
+        auto [ctx, resp] = collection.get_and_lock(id, lock_time, options).get();
         REQUIRE(ctx.ec() == couchbase::errc::common::ambiguous_timeout);
         REQUIRE(ctx.retried_because_of(couchbase::retry_reason::key_value_locked));
     }

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

@@ -321,14 +321,18 @@ TEST_CASE("integration: fetch diagnostics after N1QL query", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query() || integration.ctx.deployment == test::utils::deployment_type::elixir) {
+        SKIP("cluster does not support query or cluster level query");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     {
         couchbase::core::operations::query_request req{ "SELECT 'hello, couchbase' AS greetings" };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec);
-        INFO("rows.size() =" << resp.rows.size())
+        INFO("rows.size() =" << resp.rows.size());
         REQUIRE(resp.rows.size() == 1);
-        INFO("row=" << resp.rows[0])
+        INFO("row=" << resp.rows[0]);
         REQUIRE(resp.rows[0] == R"({"greetings":"hello, couchbase"})");
     }
     {
@@ -365,8 +369,10 @@ TEST_CASE("integration: ping", "[integration]")
         REQUIRE(res.services.count(couchbase::core::service_type::management) > 0);
         REQUIRE(res.services[couchbase::core::service_type::management].size() > 0);
 
-        REQUIRE(res.services.count(couchbase::core::service_type::view) > 0);
-        REQUIRE(res.services[couchbase::core::service_type::view].size() > 0);
+        if (integration.ctx.deployment != test::utils::deployment_type::elixir) {
+            REQUIRE(res.services.count(couchbase::core::service_type::view) > 0);
+            REQUIRE(res.services[couchbase::core::service_type::view].size() > 0);
+        }
 
         REQUIRE(res.services.count(couchbase::core::service_type::query) > 0);
         REQUIRE(res.services[couchbase::core::service_type::query].size() > 0);
@@ -385,7 +391,7 @@ TEST_CASE("integration: ping", "[integration]")
         }
 
         REQUIRE(res.id == "my_report_id");
-        INFO(res.sdk)
+        INFO(res.sdk);
         REQUIRE(res.sdk.find("cxx/") == 0);
     }
 }

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

@@ -25,7 +25,7 @@ TEST_CASE("integration: durable operations", "[integration]")
 {
     test::utils::integration_test_guard integration;
     if (!integration.cluster_version().supports_enhanced_durability()) {
-        return;
+        SKIP("cluster does not support enhanced durability");
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -68,7 +68,7 @@ TEST_CASE("integration: durable operations", "[integration]")
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        REQUIRE(resp.value == couchbase::core::utils::to_binary(R"({"foo":"bar","baz":42})"));
+        REQUIRE(couchbase::core::utils::json::parse_binary(resp.value) == couchbase::core::utils::json::parse(R"({"foo":"bar","baz":42})"));
     }
     {
         couchbase::core::operations::remove_request req{ id };
@@ -83,8 +83,13 @@ TEST_CASE("integration: durable operations", "[integration]")
 TEST_CASE("integration: legacy durability persist to active and replicate to one", "[integration]")
 {
     test::utils::integration_test_guard integration;
-    if (integration.number_of_replicas() == 0 || integration.number_of_nodes() <= integration.number_of_replicas()) {
-        return;
+    if (integration.number_of_replicas() == 0) {
+        SKIP("bucket has zero replicas");
+    }
+    if (integration.number_of_nodes() <= integration.number_of_replicas()) {
+        SKIP(fmt::format("number of nodes ({}) is less or equal to number of replicas ({})",
+                         integration.number_of_nodes(),
+                         integration.number_of_replicas()));
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -124,7 +129,7 @@ TEST_CASE("integration: low level legacy durability impossible if number of node
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     if (integration.number_of_replicas() == 3) {
-        return;
+        SKIP("bucket has three replicas configured, so the test will not be applicable");
     }
 
     couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
@@ -159,7 +164,7 @@ TEST_CASE("integration: low level legacy durability persist to active and replic
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     if (integration.number_of_replicas() < 1) {
-        return;
+        SKIP("bucket does not have replicas configured");
     }
 
     couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
@@ -211,7 +216,7 @@ TEST_CASE("integration: low level legacy durability persist to active and replic
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        REQUIRE(resp.value == couchbase::core::utils::to_binary(R"({"foo":"bar","baz":42})"));
+        REQUIRE(couchbase::core::utils::json::parse_binary(resp.value) == couchbase::core::utils::json::parse(R"({"foo":"bar","baz":42})"));
     }
     {
         couchbase::core::operations::remove_request_with_legacy_durability req{