couchbase 3.4.1 → 3.4.3

data/ext/couchbase/test/test_integration_management.cxx

@@ -17,6 +17,8 @@
 
 #include "test_helper_integration.hxx"
 
+#include <catch2/catch_approx.hpp>
+
 #include "core/management/analytics_link.hxx"
 #include "core/operations/management/analytics.hxx"
 #include "core/operations/management/bucket.hxx"
@@ -32,6 +34,8 @@
 #include "couchbase/drop_query_index_options.hxx"
 #include "couchbase/watch_query_indexes_options.hxx"
 
+using Catch::Approx;
+
 static couchbase::core::operations::management::bucket_get_response
 wait_for_bucket_created(test::utils::integration_test_guard& integration, const std::string& bucket_name)
 {
@@ -59,7 +63,7 @@ TEST_CASE("integration: bucket management", "[integration]")
     test::utils::integration_test_guard integration;
 
     if (!integration.cluster_version().supports_bucket_management()) {
-        return;
+        SKIP("cluster does not support bucket management");
     }
 
     if (!integration.cluster_version().supports_gcccp()) {
@@ -108,7 +112,7 @@ TEST_CASE("integration: bucket management", "[integration]")
         {
             couchbase::core::operations::management::bucket_get_all_request req{};
             auto resp = test::utils::execute(integration.cluster, req);
-            INFO(resp.ctx.http_body)
+            INFO(resp.ctx.http_body);
             REQUIRE_SUCCESS(resp.ctx.ec);
             bool found = false;
             for (const auto& bucket : resp.buckets) {
@@ -508,7 +512,7 @@ TEST_CASE("integration: collection management", "[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");
@@ -648,7 +652,7 @@ TEST_CASE("integration: user groups management", "[integration]")
     test::utils::integration_test_guard integration;
 
     if (!integration.cluster_version().supports_user_groups()) {
-        return;
+        SKIP("cluster does not support user groups");
     }
 
     SECTION("group crud")
@@ -859,7 +863,7 @@ TEST_CASE("integration: user management", "[integration]")
     test::utils::integration_test_guard integration;
 
     if (!integration.cluster_version().supports_user_management()) {
-        return;
+        SKIP("cluster does not support user management");
     }
 
     if (!integration.cluster_version().supports_gcccp()) {
@@ -957,9 +961,14 @@ TEST_CASE("integration: user management collections roles", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    if (!integration.cluster_version().supports_user_management() || !integration.cluster_version().supports_collections() ||
-        integration.cluster_version().is_community()) {
-        return;
+    if (!integration.cluster_version().supports_user_management()) {
+        SKIP("cluster does not support user management");
+    }
+    if (!integration.cluster_version().supports_collections()) {
+        SKIP("cluster does not support collections");
+    }
+    if (integration.cluster_version().is_community()) {
+        SKIP("cluster is community edition");
     }
 
     auto scope_name = test::utils::uniq_id("scope");
@@ -1033,6 +1042,10 @@ TEST_CASE("integration: query index management", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query_index_management()) {
+        SKIP("cluster does not support query index management");
+    }
+
     if (integration.cluster_version().supports_bucket_management()) {
         SECTION("primary index")
         {
@@ -1440,8 +1453,11 @@ TEST_CASE("integration: collections query index management", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query_index_management()) {
+        SKIP("cluster does not support query index management");
+    }
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
 
     auto index_name = test::utils::uniq_id("collections_index");
@@ -1956,13 +1972,14 @@ TEST_CASE("integration: analytics index management", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
-    if (!integration.cluster_version().supports_analytics() || !integration.has_analytics_service()) {
-        return;
+    if (!integration.cluster_version().supports_analytics()) {
+        SKIP("cluster does not support analytics service");
+    }
+    if (!integration.has_analytics_service()) {
+        SKIP("cluster does not have analytics service");
     }
-
-    // MB-47718
     if (integration.storage_backend() == couchbase::core::management::cluster::bucket_storage_backend::magma) {
-        return;
+        SKIP("analytics does not work with magma storage backend, see MB-47718");
     }
 
     SECTION("crud")
@@ -2488,18 +2505,20 @@ TEST_CASE("integration: analytics external link management", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
-    if (!integration.cluster_version().supports_analytics_links() || !integration.has_analytics_service()) {
-        return;
+    if (!integration.cluster_version().supports_analytics()) {
+        SKIP("cluster does not support analytics service");
+    }
+    if (!integration.has_analytics_service()) {
+        SKIP("cluster does not have analytics service");
+    }
+    if (!integration.cluster_version().supports_analytics_links()) {
+        SKIP("analytics does not support analytics links");
     }
-
-    // MB-47718
     if (integration.storage_backend() == couchbase::core::management::cluster::bucket_storage_backend::magma) {
-        return;
+        SKIP("analytics does not work with magma storage backend, see MB-47718");
     }
-
-    // MB-40198
     if (!integration.cluster_version().supports_analytics_links_cert_auth() && integration.origin.credentials().uses_certificate()) {
-        return;
+        SKIP("certificate credentials selected, but analytics service does not support cert auth, see MB-40198");
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -2589,6 +2608,10 @@ TEST_CASE("integration: search index management", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_search()) {
+        SKIP("cluster does not support search");
+    }
+
     if (!integration.cluster_version().supports_gcccp()) {
         test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     }
@@ -2851,11 +2874,23 @@ wait_for_search_pindexes_ready(test::utils::integration_test_guard& integration,
               return false;
           }
           auto stats = couchbase::core::utils::json::parse(resp.stats);
-          const auto* num_pindexes_actual = stats.find(fmt::format("{}:{}:num_pindexes_actual", integration.ctx.bucket, index_name));
+
+          const auto num_pindexes_actual_key = fmt::format("{}:{}:num_pindexes_actual", integration.ctx.bucket, index_name);
+          const auto num_pindexes_target_key = fmt::format("{}:{}:num_pindexes_target", integration.ctx.bucket, index_name);
+          const auto* num_pindexes_actual = stats.find(num_pindexes_actual_key);
+          const auto* num_pindexes_target = stats.find(num_pindexes_target_key);
+          CB_LOG_DEBUG(
+            "wait_for_search_pindexes_ready: {}={}, {}={}",
+            num_pindexes_actual_key,
+            (num_pindexes_actual == nullptr || !num_pindexes_actual->is_number()) ? "missing"
+                                                                                  : std::to_string(num_pindexes_actual->get_unsigned()),
+            num_pindexes_target_key,
+            (num_pindexes_target == nullptr || !num_pindexes_target->is_number()) ? "missing"
+                                                                                  : std::to_string(num_pindexes_target->get_unsigned()));
+
           if (num_pindexes_actual == nullptr || !num_pindexes_actual->is_number()) {
               return false;
           }
-          const auto* num_pindexes_target = stats.find(fmt::format("{}:{}:num_pindexes_target", integration.ctx.bucket, index_name));
           if (num_pindexes_target == nullptr || !num_pindexes_target->is_number()) {
               return false;
           }
@@ -2868,8 +2903,12 @@ TEST_CASE("integration: search index management analyze document", "[integration
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_search()) {
+        SKIP("cluster does not support search");
+    }
+
     if (!integration.cluster_version().supports_search_analyze()) {
-        return;
+        SKIP("cluster does not support search analyze");
     }
 
     auto index_name = test::utils::uniq_id("index");
@@ -2889,7 +2928,7 @@ TEST_CASE("integration: search index management analyze document", "[integration
         REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
-    REQUIRE(wait_for_search_pindexes_ready(integration, index_name));
+    REQUIRE(test::utils::wait_for_search_pindexes_ready(integration.cluster, integration.ctx.bucket, index_name));
 
     couchbase::core::operations::management::search_index_analyze_document_response resp;
     bool operation_completed = test::utils::wait_until([&integration, &index_name, &resp]() {
@@ -2920,25 +2959,34 @@ TEST_CASE("integration: freeform HTTP request", "[integration]")
         REQUIRE(resp.ctx.ec == couchbase::errc::common::invalid_argument);
     }
 
-    if (integration.cluster_version().supports_analytics() && integration.has_analytics_service()) {
-        SECTION("analytics")
-        {
-            couchbase::core::operations::management::freeform_request req{};
-            req.type = couchbase::core::service_type::analytics;
-            req.method = "GET";
-            req.path = "/admin/ping";
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_SUCCESS(resp.ctx.ec);
-            REQUIRE(resp.status == 200);
-            REQUIRE_FALSE(resp.body.empty());
-            INFO(resp.body)
-            auto result = couchbase::core::utils::json::parse(resp.body);
-            REQUIRE(result.is_object());
+    SECTION("analytics")
+    {
+        if (!integration.cluster_version().supports_analytics()) {
+            SKIP("cluster does not support analytics");
+        }
+        if (!integration.has_analytics_service()) {
+            SKIP("cluster does not have analytics service");
         }
+
+        couchbase::core::operations::management::freeform_request req{};
+        req.type = couchbase::core::service_type::analytics;
+        req.method = "GET";
+        req.path = "/admin/ping";
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        REQUIRE(resp.status == 200);
+        REQUIRE_FALSE(resp.body.empty());
+        INFO(resp.body);
+        auto result = couchbase::core::utils::json::parse(resp.body);
+        REQUIRE(result.is_object());
     }
 
     SECTION("search")
     {
+        if (!integration.cluster_version().supports_search()) {
+            SKIP("cluster does not support search");
+        }
+
         couchbase::core::operations::management::freeform_request req{};
         req.type = couchbase::core::service_type::search;
         req.method = "GET";
@@ -2953,6 +3001,10 @@ TEST_CASE("integration: freeform HTTP request", "[integration]")
 
     SECTION("query")
     {
+        if (!integration.cluster_version().supports_query()) {
+            SKIP("cluster does not support query");
+        }
+
         couchbase::core::operations::management::freeform_request req{};
         req.type = couchbase::core::service_type::query;
         req.method = "GET";
@@ -2961,30 +3013,32 @@ TEST_CASE("integration: freeform HTTP request", "[integration]")
         REQUIRE_SUCCESS(resp.ctx.ec);
         REQUIRE(resp.status == 200);
         REQUIRE_FALSE(resp.body.empty());
-        INFO(resp.body)
+        INFO(resp.body);
         auto result = couchbase::core::utils::json::parse(resp.body);
         REQUIRE(result.is_object());
     }
 
-    if (integration.cluster_version().supports_views()) {
-        SECTION("view")
-        {
-            auto document_name = test::utils::uniq_id("design_document");
-            auto view_name = test::utils::uniq_id("view");
-
-            couchbase::core::operations::management::freeform_request req{};
-            req.type = couchbase::core::service_type::view;
-            req.method = "POST";
-            req.path = fmt::format("/{}/_design/{}/_view/{}", integration.ctx.bucket, document_name, view_name);
-            req.body = R"({"keys":["foo","bar"]})";
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_SUCCESS(resp.ctx.ec);
-            REQUIRE(resp.status == 404);
-            REQUIRE_FALSE(resp.body.empty());
-            auto result = couchbase::core::utils::json::parse(resp.body);
-            INFO(resp.body)
-            REQUIRE(result["error"].get_string() == "not_found");
+    SECTION("view")
+    {
+        if (!integration.cluster_version().supports_views()) {
+            SKIP("cluster does not support views");
         }
+
+        auto document_name = test::utils::uniq_id("design_document");
+        auto view_name = test::utils::uniq_id("view");
+
+        couchbase::core::operations::management::freeform_request req{};
+        req.type = couchbase::core::service_type::view;
+        req.method = "POST";
+        req.path = fmt::format("/{}/_design/{}/_view/{}", integration.ctx.bucket, document_name, view_name);
+        req.body = R"({"keys":["foo","bar"]})";
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        REQUIRE(resp.status == 404);
+        REQUIRE_FALSE(resp.body.empty());
+        auto result = couchbase::core::utils::json::parse(resp.body);
+        INFO(resp.body);
+        REQUIRE(result["error"].get_string() == "not_found");
     }
 
     SECTION("management")
@@ -2998,48 +3052,59 @@ TEST_CASE("integration: freeform HTTP request", "[integration]")
         REQUIRE(resp.status == 200);
         REQUIRE_FALSE(resp.body.empty());
         auto result = couchbase::core::utils::json::parse(resp.body);
-        INFO(resp.body)
+        INFO(resp.body);
         REQUIRE(result.find("uuid") != nullptr);
     }
 
-    if (integration.cluster_version().supports_collections()) {
-        SECTION("create scope")
-        {
-            auto scope_name = test::utils::uniq_id("freeform_scope");
+    SECTION("create scope")
+    {
+        if (!integration.cluster_version().supports_collections()) {
+            SKIP("cluster does not support collections");
+        }
 
-            couchbase::core::operations::management::freeform_request req{};
-            req.type = couchbase::core::service_type::management;
-            req.method = "POST";
-            req.path = fmt::format("/pools/default/buckets/{}/scopes", integration.ctx.bucket);
-            req.headers["content-type"] = "application/x-www-form-urlencoded";
-            req.body = fmt::format("name={}", couchbase::core::utils::string_codec::form_encode(scope_name));
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_SUCCESS(resp.ctx.ec);
-            REQUIRE(resp.status == 200);
-            REQUIRE_FALSE(resp.headers.empty());
+        auto scope_name = test::utils::uniq_id("freeform_scope");
+
+        couchbase::core::operations::management::freeform_request req{};
+        req.type = couchbase::core::service_type::management;
+        req.method = "POST";
+        req.path = fmt::format("/pools/default/buckets/{}/scopes", integration.ctx.bucket);
+        req.headers["content-type"] = "application/x-www-form-urlencoded";
+        req.body = fmt::format("name={}", couchbase::core::utils::string_codec::form_encode(scope_name));
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        REQUIRE(resp.status == 200);
+        REQUIRE_FALSE(resp.headers.empty());
+        if (integration.cluster_version().is_mock()) {
+            REQUIRE(resp.headers["content-type"].find("application/json") == std::string::npos);
+            REQUIRE(resp.headers["content-type"].find("text/plain") != std::string::npos);
+        } else {
             REQUIRE(resp.headers["content-type"].find("application/json") != std::string::npos);
-            auto result = couchbase::core::utils::json::parse(resp.body);
-            REQUIRE(result.is_object());
-            REQUIRE(result.find("uid") != nullptr);
         }
+        auto result = couchbase::core::utils::json::parse(resp.body);
+        REQUIRE(result.is_object());
+        REQUIRE(result.find("uid") != nullptr);
     }
 
-    if (integration.cluster_version().supports_eventing_functions() && integration.has_eventing_service()) {
-        SECTION("eventing")
-        {
-
-            couchbase::core::operations::management::freeform_request req{};
-            req.type = couchbase::core::service_type::eventing;
-            req.method = "GET";
-            req.path = "/api/v1/functions";
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_SUCCESS(resp.ctx.ec);
-            REQUIRE(resp.status == 200);
-            REQUIRE_FALSE(resp.body.empty());
-            auto result = couchbase::core::utils::json::parse(resp.body);
-            INFO(resp.body)
-            REQUIRE(result.is_array());
+    SECTION("eventing")
+    {
+        if (!integration.cluster_version().supports_eventing_functions()) {
+            SKIP("cluster does not support eventing functions");
         }
+        if (!integration.has_eventing_service()) {
+            SKIP("cluster does not have eventing service");
+        }
+
+        couchbase::core::operations::management::freeform_request req{};
+        req.type = couchbase::core::service_type::eventing;
+        req.method = "GET";
+        req.path = "/api/v1/functions";
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+        REQUIRE(resp.status == 200);
+        REQUIRE_FALSE(resp.body.empty());
+        auto result = couchbase::core::utils::json::parse(resp.body);
+        INFO(resp.body);
+        REQUIRE(result.is_array());
     }
 }
 
@@ -3082,8 +3147,11 @@ TEST_CASE("integration: eventing functions management", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
-    if (!integration.cluster_version().supports_eventing_functions() || !integration.has_eventing_service()) {
-        return;
+    if (!integration.cluster_version().supports_eventing_functions()) {
+        SKIP("cluster does not support eventing service");
+    }
+    if (!integration.has_eventing_service()) {
+        SKIP("cluster does not have eventing service");
     }
 
     if (!integration.cluster_version().supports_gcccp()) {

data/ext/couchbase/test/test_integration_query.cxx

@@ -31,6 +31,10 @@ TEST_CASE("integration: trivial non-data query", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query()) {
+        SKIP("cluster does not support query");
+    }
+
     if (!integration.cluster_version().supports_gcccp()) {
         test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     }
@@ -46,6 +50,10 @@ TEST_CASE("integration: query with handler capturing non-copyable object", "[int
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query()) {
+        SKIP("cluster does not support query");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     if (!integration.cluster_version().supports_gcccp()) {
@@ -70,9 +78,14 @@ TEST_CASE("integration: query with handler capturing non-copyable object", "[int
 TEST_CASE("integration: query on a collection", "[integration]")
 {
     test::utils::integration_test_guard integration;
+
+    if (!integration.cluster_version().supports_query()) {
+        SKIP("cluster does not support query");
+    }
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     auto scope_name = test::utils::uniq_id("scope");
@@ -109,7 +122,7 @@ TEST_CASE("integration: query on a collection", "[integration]")
         req.index_name = index_name;
         req.is_primary = true;
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.http_body)
+        INFO(resp.ctx.http_body);
         REQUIRE_SUCCESS(resp.ctx.ec);
     }
 
@@ -172,6 +185,10 @@ TEST_CASE("integration: read only with no results", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query()) {
+        SKIP("cluster does not support query");
+    }
+
     if (!integration.cluster_version().supports_gcccp()) {
         test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     }
@@ -188,6 +205,10 @@ TEST_CASE("integration: invalid query", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query()) {
+        SKIP("cluster does not support query");
+    }
+
     if (!integration.cluster_version().supports_gcccp()) {
         test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     }
@@ -199,12 +220,16 @@ TEST_CASE("integration: invalid query", "[integration]")
     }
 }
 
-TEST_CASE("integration: preserve expiry for mutatation query", "[integration]")
+TEST_CASE("integration: preserve expiry for mutation query", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query()) {
+        SKIP("cluster does not support query");
+    }
+
     if (!integration.cluster_version().supports_preserve_expiry_for_query()) {
-        return;
+        SKIP("cluster does not support support preserve expiry for query");
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -264,6 +289,10 @@ TEST_CASE("integration: streaming query results", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query()) {
+        SKIP("cluster does not support query");
+    }
+
     if (!integration.cluster_version().supports_gcccp()) {
         test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     }
@@ -286,6 +315,10 @@ TEST_CASE("integration: streaming query results with stop in the middle", "[inte
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query()) {
+        SKIP("cluster does not support query");
+    }
+
     if (!integration.cluster_version().supports_gcccp()) {
         test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     }
@@ -315,8 +348,11 @@ TEST_CASE("integration: streaming analytics results", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
-    if (!integration.cluster_version().supports_analytics() || !integration.has_analytics_service()) {
-        return;
+    if (!integration.cluster_version().supports_analytics()) {
+        SKIP("cluster does not support analytics");
+    }
+    if (!integration.has_analytics_service()) {
+        SKIP("cluster does not have analytics service");
     }
 
     if (!integration.cluster_version().supports_gcccp()) {
@@ -345,6 +381,10 @@ TEST_CASE("integration: sticking query to the service node", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query()) {
+        SKIP("cluster does not support query");
+    }
+
     if (!integration.cluster_version().supports_gcccp()) {
         test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     }
@@ -412,10 +452,16 @@ TEST_CASE("analytics create dataset")
 {
     test::utils::integration_test_guard integration;
 
-    if (!integration.cluster_version().supports_analytics() || !integration.has_analytics_service() ||
-        !integration.cluster_version().supports_collections()) {
-        return;
+    if (!integration.cluster_version().supports_analytics()) {
+        SKIP("cluster does not support analytics");
+    }
+    if (!integration.cluster_version().supports_collections()) {
+        SKIP("cluster does not support collections");
+    }
+    if (!integration.has_analytics_service()) {
+        SKIP("cluster does not have analytics service");
     }
+
     if (!integration.cluster_version().supports_gcccp()) {
         test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     }
@@ -434,6 +480,11 @@ TEST_CASE("analytics create dataset")
 TEST_CASE("integration: prepared query", "[integration]")
 {
     test::utils::integration_test_guard integration;
+
+    if (!integration.cluster_version().supports_query()) {
+        SKIP("cluster does not support query");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     auto key = test::utils::uniq_id("foo");
     tao::json::value value = {
@@ -468,6 +519,10 @@ TEST_CASE("integration: query with public API", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query()) {
+        SKIP("cluster does not support query");
+    }
+
     if (!integration.cluster_version().supports_gcccp()) {
         test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     }
@@ -505,8 +560,11 @@ TEST_CASE("integration: query from scope with public API", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_query()) {
+        SKIP("cluster does not support query");
+    }
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
 
     if (!integration.cluster_version().supports_gcccp()) {