couchbase 3.4.2 → 3.4.4

data/ext/couchbase/test/test_integration_read_replica.cxx

@@ -63,8 +63,13 @@ TEST_CASE("integration: get any replica", "[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);
@@ -95,8 +100,12 @@ TEST_CASE("integration: get all replicas", "[integration]")
     test::utils::integration_test_guard integration;
 
     auto number_of_replicas = integration.number_of_replicas();
-    if (number_of_replicas == 0 && integration.number_of_nodes() <= number_of_replicas) {
-        return;
+    if (number_of_replicas == 0) {
+        SKIP("bucket has zero replicas");
+    }
+    if (integration.number_of_nodes() <= number_of_replicas) {
+        SKIP(fmt::format(
+          "number of nodes ({}) is less or equal to number of replicas ({})", integration.number_of_nodes(), number_of_replicas));
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -109,10 +118,16 @@ TEST_CASE("integration: get all replicas", "[integration]")
         couchbase::core::document_id id{ integration.ctx.bucket, scope_name, collection_name, key };
 
         couchbase::core::operations::insert_request req{ id, basic_doc_json };
+        req.durability_level = couchbase::durability_level::majority_and_persist_to_active;
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
+    if (integration.cluster_version().is_mock()) {
+        // GOCAVES does not implement syncDurability. See https://github.com/couchbaselabs/gocaves/issues/109
+        std::this_thread::sleep_for(std::chrono::seconds{ 1 });
+    }
+
     {
         auto collection =
           couchbase::cluster(integration.cluster).bucket(integration.ctx.bucket).scope(scope_name).collection(collection_name);
@@ -128,8 +143,13 @@ TEST_CASE("integration: get all replicas with missing key", "[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);
@@ -152,7 +172,9 @@ TEST_CASE("integration: get any replica with missing key", "[integration]")
     test::utils::integration_test_guard integration;
 
     if (integration.number_of_nodes() <= integration.number_of_replicas()) {
-        return;
+        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);
@@ -173,8 +195,13 @@ TEST_CASE("integration: get any replica low-level version", "[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);
@@ -204,8 +231,12 @@ TEST_CASE("integration: get all replicas low-level version", "[integration]")
     test::utils::integration_test_guard integration;
 
     auto number_of_replicas = integration.number_of_replicas();
-    if (number_of_replicas == 0 && integration.number_of_nodes() <= integration.number_of_replicas()) {
-        return;
+    if (number_of_replicas == 0) {
+        SKIP("bucket has zero replicas");
+    }
+    if (integration.number_of_nodes() <= number_of_replicas) {
+        SKIP(fmt::format(
+          "number of nodes ({}) is less or equal to number of replicas ({})", integration.number_of_nodes(), number_of_replicas));
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -217,10 +248,16 @@ TEST_CASE("integration: get all replicas low-level version", "[integration]")
             { "b", 2.0 },
         };
         couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::json::generate_binary(value) };
+        req.durability_level = couchbase::durability_level::majority_and_persist_to_active;
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec());
     }
 
+    if (integration.cluster_version().is_mock()) {
+        // GOCAVES does not implement syncDurability. See https://github.com/couchbaselabs/gocaves/issues/109
+        std::this_thread::sleep_for(std::chrono::seconds{ 1 });
+    }
+
     {
         couchbase::core::operations::get_all_replicas_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);

data/ext/couchbase/test/test_integration_search.cxx

@@ -17,16 +17,26 @@
 
 #include "test_helper_integration.hxx"
 
+#include <catch2/matchers/catch_matchers_string.hpp>
+
 #include "core/operations/management/collection_create.hxx"
 #include "core/operations/management/search_index_drop.hxx"
 #include "core/operations/management/search_index_upsert.hxx"
 
+#include <couchbase/query_string_query.hxx>
+
+#include <regex>
+
 using Catch::Matchers::StartsWith;
 
 TEST_CASE("integration: search query")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_search()) {
+        SKIP("cluster does not support search");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     {
@@ -348,6 +358,14 @@ TEST_CASE("integration: search query consistency", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
+    if (integration.ctx.deployment == test::utils::deployment_type::elixir) {
+        SKIP("elixir deployment is incompatible with parts of this test");
+    }
+
+    if (!integration.cluster_version().supports_search()) {
+        SKIP("cluster does not support search");
+    }
+
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     const std::string params =
@@ -441,7 +459,7 @@ TEST_CASE("integration: search query consistency", "[integration]")
                 CB_LOG_INFO("ignore consistency_mismatch: {}", resp.ctx.http_body);
                 continue;
             }
-            INFO(resp.ctx.http_body)
+            INFO(resp.ctx.http_body);
             REQUIRE_SUCCESS(resp.ctx.ec);
             switch (resp.rows.size()) {
                 case 1:
@@ -474,8 +492,12 @@ TEST_CASE("integration: search query collections")
 {
     test::utils::integration_test_guard integration;
 
+    if (!integration.cluster_version().supports_search()) {
+        SKIP("cluster does not support search");
+    }
+
     if (!integration.cluster_version().supports_collections()) {
-        return;
+        SKIP("cluster does not support collections");
     }
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
@@ -547,7 +569,14 @@ TEST_CASE("integration: search query collections")
         }
         couchbase::core::operations::management::search_index_upsert_request req{};
         req.index = index;
-        auto resp = test::utils::execute(integration.cluster, req);
+
+        couchbase::core::operations::management::search_index_upsert_response resp;
+        bool operation_completed = test::utils::wait_until([&integration, &resp, req]() {
+            resp = test::utils::execute(integration.cluster, req);
+            std::regex scope_not_found("collection: '.+' doesn't belong to scope");
+            return !std::regex_search(resp.error, scope_not_found);
+        });
+        REQUIRE(operation_completed);
         REQUIRE_SUCCESS(resp.ctx.ec);
         if (index_name != resp.name) {
             CB_LOG_INFO("update index name \"{}\" -> \"{}\"", index_name, resp.name);