Replace feature_not_available handling in update/create collection response with bucket cap check

Author: DemetrisChr

core/operations/management/collection_create.cxx

@@ -28,7 +28,7 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-collection_create_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+collection_create_request::encode_to(encoded_request_type& encoded, http_context& context) const
 {
     encoded.method = "POST";
     encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections", bucket_name, scope_name);
@@ -42,6 +42,11 @@ collection_create_request::encode_to(encoded_request_type& encoded, http_context
         return couchbase::errc::common::invalid_argument;
     }
     if (history.has_value()) {
+        auto bucket_caps = context.config.bucket_capabilities;
+        if (bucket_caps.find(bucket_capability::non_deduped_history) == bucket_caps.end()) {
+            return errc::common::feature_not_available;
+        }
+
         encoded.body.append(fmt::format("&history={}", history.value()));
     }
     return {};
@@ -57,9 +62,6 @@ collection_create_request::make_response(error_context::http&& ctx, const encode
                 std::regex collection_exists("Collection with name .+ already exists");
                 if (std::regex_search(encoded.body.data(), collection_exists)) {
                     response.ctx.ec = errc::management::collection_exists;
-                } else if (encoded.body.data().find("Not allowed on this version of cluster") != std::string::npos ||
-                           encoded.body.data().find("Bucket must have storage_mode=magma") != std::string::npos) {
-                    response.ctx.ec = errc::common::feature_not_available;
                 } else {
                     response.ctx.ec = errc::common::invalid_argument;
                 }

core/operations/management/collection_update.cxx

@@ -28,7 +28,7 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-collection_update_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+collection_update_request::encode_to(encoded_request_type& encoded, http_context& context) const
 {
     encoded.method = "PATCH";
     encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections/{}", bucket_name, scope_name, collection_name);
@@ -42,6 +42,11 @@ collection_update_request::encode_to(encoded_request_type& encoded, http_context
         }
     }
     if (history.has_value()) {
+        auto bucket_caps = context.config.bucket_capabilities;
+        if (bucket_caps.find(bucket_capability::non_deduped_history) == bucket_caps.end()) {
+            return errc::common::feature_not_available;
+        }
+
         values["history"] = history.value() ? "true" : "false";
     }
     encoded.body = utils::string_codec::v2::form_encode(values);
@@ -55,12 +60,7 @@ collection_update_request::make_response(error_context::http&& ctx, const encode
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400: {
-                if (encoded.body.data().find("Not allowed on this version of cluster") != std::string::npos ||
-                    encoded.body.data().find("Bucket must have storage_mode=magma") != std::string::npos) {
-                    response.ctx.ec = errc::common::feature_not_available;
-                } else {
-                    response.ctx.ec = errc::common::invalid_argument;
-                }
+                response.ctx.ec = errc::common::invalid_argument;
             } break;
             case 404: {
                 std::regex scope_not_found("Scope with name .+ is not found");

test/test_integration_management.cxx

@@ -987,6 +987,7 @@ TEST_CASE("integration: bucket management history", "[integration]")
             REQUIRE(get_resp.bucket.history_retention_bytes == 2147483648);
         }
     }
+
     {
         couchbase::core::operations::management::bucket_drop_request req{ bucket_name };
         couchbase::core::operations::management::bucket_drop_request update_req{ update_bucket_name };
@@ -1539,6 +1540,56 @@ TEST_CASE("integration: collection management update collection with max expiry"
     }
 }
 
+TEST_CASE("integration: collection management history retention not supported in bucket", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    if (integration.has_bucket_capability("nonDedupedHistory")) {
+        SKIP("Bucket supports non deduped history");
+    }
+
+    auto scope_name = "_default";
+    auto collection_name = test::utils::uniq_id("collection");
+
+    SECTION("create collection")
+    {
+        couchbase::core::operations::management::collection_create_request req{
+            integration.ctx.bucket,
+            scope_name,
+            collection_name,
+        };
+
+        req.history = true;
+
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE(resp.ctx.ec == couchbase::errc::common::feature_not_available);
+    }
+
+    SECTION("update collection")
+    {
+        auto ec = create_collection(integration.cluster, integration.ctx.bucket, scope_name, collection_name);
+        REQUIRE_SUCCESS(ec);
+
+        couchbase::core::operations::management::collection_update_request req{
+            integration.ctx.bucket,
+            scope_name,
+            collection_name,
+        };
+
+        req.history = true;
+
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE(resp.ctx.ec == couchbase::errc::common::feature_not_available);
+    }
+
+    // Clean up the collection that was created
+    {
+        auto ec = drop_collection(integration.cluster, integration.ctx.bucket, scope_name, collection_name);
+        REQUIRE((!ec || ec == couchbase::errc::common::collection_not_found));
+    }
+}
+
 TEST_CASE("integration: collection management bucket dedup", "[integration]")
 {
     test::utils::integration_test_guard integration;