couchbase 3.4.2 → 3.4.4

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()) {
@@ -70,244 +74,555 @@ TEST_CASE("integration: bucket management", "[integration]")
 
     SECTION("crud")
     {
-        couchbase::core::management::cluster::bucket_settings bucket_settings;
-        bucket_settings.name = bucket_name;
-        bucket_settings.ram_quota_mb = 100;
-        bucket_settings.num_replicas = 1;
-        bucket_settings.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
-        bucket_settings.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::value_only;
-        bucket_settings.flush_enabled = true;
-        if (integration.cluster_version().is_enterprise()) {
-            bucket_settings.max_expiry = 10;
-            bucket_settings.compression_mode = couchbase::core::management::cluster::bucket_compression::active;
-        }
-        bucket_settings.replica_indexes = true;
-        bucket_settings.conflict_resolution_type = couchbase::core::management::cluster::bucket_conflict_resolution::sequence_number;
-
+        SECTION("core API")
         {
-            couchbase::core::operations::management::bucket_create_request req;
-            req.bucket = bucket_settings;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_SUCCESS(resp.ctx.ec);
-        }
+            couchbase::core::management::cluster::bucket_settings bucket_settings;
+            bucket_settings.name = bucket_name;
+            bucket_settings.ram_quota_mb = 100;
+            bucket_settings.num_replicas = 1;
+            bucket_settings.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
+            bucket_settings.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::value_only;
+            bucket_settings.flush_enabled = true;
+            if (integration.cluster_version().is_enterprise()) {
+                bucket_settings.max_expiry = 10;
+                bucket_settings.compression_mode = couchbase::core::management::cluster::bucket_compression::active;
+            }
+            bucket_settings.replica_indexes = true;
+            bucket_settings.conflict_resolution_type = couchbase::core::management::cluster::bucket_conflict_resolution::sequence_number;
+            {
+                couchbase::core::operations::management::bucket_create_request req;
+                req.bucket = bucket_settings;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
 
-        {
-            auto resp = wait_for_bucket_created(integration, bucket_name);
-            REQUIRE_SUCCESS(resp.ctx.ec);
-            REQUIRE(bucket_settings.bucket_type == resp.bucket.bucket_type);
-            REQUIRE(bucket_settings.name == resp.bucket.name);
-            REQUIRE(Approx(bucket_settings.ram_quota_mb).margin(5) == resp.bucket.ram_quota_mb);
-            REQUIRE(bucket_settings.num_replicas == resp.bucket.num_replicas);
-            REQUIRE(bucket_settings.flush_enabled == resp.bucket.flush_enabled);
-            REQUIRE(bucket_settings.max_expiry == resp.bucket.max_expiry);
-            REQUIRE(bucket_settings.eviction_policy == resp.bucket.eviction_policy);
-            REQUIRE(bucket_settings.compression_mode == resp.bucket.compression_mode);
-            REQUIRE(bucket_settings.replica_indexes == resp.bucket.replica_indexes);
+            {
+                auto resp = wait_for_bucket_created(integration, bucket_name);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                REQUIRE(bucket_settings.bucket_type == resp.bucket.bucket_type);
+                REQUIRE(bucket_settings.name == resp.bucket.name);
+                REQUIRE(Approx(bucket_settings.ram_quota_mb).margin(5) == resp.bucket.ram_quota_mb);
+                REQUIRE(bucket_settings.num_replicas == resp.bucket.num_replicas);
+                REQUIRE(bucket_settings.flush_enabled == resp.bucket.flush_enabled);
+                REQUIRE(bucket_settings.max_expiry == resp.bucket.max_expiry);
+                REQUIRE(bucket_settings.eviction_policy == resp.bucket.eviction_policy);
+                REQUIRE(bucket_settings.compression_mode == resp.bucket.compression_mode);
+                REQUIRE(bucket_settings.replica_indexes == resp.bucket.replica_indexes);
+            }
+            std::uint64_t old_quota_mb{ 0 };
+            {
+                couchbase::core::operations::management::bucket_get_all_request req{};
+                auto resp = test::utils::execute(integration.cluster, req);
+                INFO(resp.ctx.http_body);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                bool found = false;
+                for (const auto& bucket : resp.buckets) {
+                    if (bucket.name != bucket_name) {
+                        continue;
+                    }
+                    found = true;
+                    REQUIRE(bucket_settings.bucket_type == bucket.bucket_type);
+                    REQUIRE(bucket_settings.name == bucket.name);
+                    REQUIRE(bucket_settings.ram_quota_mb == bucket.ram_quota_mb);
+                    old_quota_mb = bucket_settings.ram_quota_mb;
+                    REQUIRE(bucket_settings.num_replicas == bucket.num_replicas);
+                    REQUIRE(bucket_settings.flush_enabled == bucket.flush_enabled);
+                    REQUIRE(bucket_settings.max_expiry == bucket.max_expiry);
+                    REQUIRE(bucket_settings.eviction_policy == bucket.eviction_policy);
+                    REQUIRE(bucket_settings.compression_mode == bucket.compression_mode);
+                    REQUIRE(bucket_settings.replica_indexes == bucket.replica_indexes);
+                    break;
+                }
+                REQUIRE(found);
+            }
+
+            {
+                bucket_settings.ram_quota_mb = old_quota_mb + 20;
+                couchbase::core::operations::management::bucket_update_request req;
+                req.bucket = bucket_settings;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
+
+            auto ram_quota_updated = test::utils::wait_until([&integration, &bucket_name, old_quota_mb]() {
+                couchbase::core::operations::management::bucket_get_request req{ bucket_name };
+                auto resp = test::utils::execute(integration.cluster, req);
+                return !resp.ctx.ec && resp.bucket.ram_quota_mb > old_quota_mb;
+            });
+            REQUIRE(ram_quota_updated);
+
+            {
+                couchbase::core::operations::management::bucket_drop_request req{ bucket_name };
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
+
+            {
+                couchbase::core::operations::management::bucket_get_request req{ bucket_name };
+                auto resp = retry_on_error(integration, req, {});
+                REQUIRE(resp.ctx.ec == couchbase::errc::common::bucket_not_found);
+            }
+
+            {
+                couchbase::core::operations::management::bucket_get_all_request req;
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+                REQUIRE(!resp.buckets.empty());
+                auto known_buckets = std::count_if(
+                  resp.buckets.begin(), resp.buckets.end(), [&bucket_name](auto& entry) { return entry.name == bucket_name; });
+                REQUIRE(known_buckets == 0);
+            }
         }
-        std::uint64_t old_quota_mb{ 0 };
+        SECTION("public API")
         {
-            couchbase::core::operations::management::bucket_get_all_request req{};
-            auto resp = test::utils::execute(integration.cluster, req);
-            INFO(resp.ctx.http_body)
-            REQUIRE_SUCCESS(resp.ctx.ec);
-            bool found = false;
-            for (const auto& bucket : resp.buckets) {
-                if (bucket.name != bucket_name) {
-                    continue;
-                }
-                found = true;
+            couchbase::cluster c(integration.cluster);
+            couchbase::management::cluster::bucket_settings bucket_settings;
+            bucket_settings.name = bucket_name;
+            bucket_settings.ram_quota_mb = 100;
+            bucket_settings.num_replicas = 1;
+            bucket_settings.bucket_type = couchbase::management::cluster::bucket_type::couchbase;
+            bucket_settings.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::value_only;
+            bucket_settings.flush_enabled = true;
+            if (integration.cluster_version().is_enterprise()) {
+                bucket_settings.max_expiry = 10;
+                bucket_settings.compression_mode = couchbase::management::cluster::bucket_compression::active;
+            }
+            bucket_settings.replica_indexes = true;
+            bucket_settings.conflict_resolution_type = couchbase::management::cluster::bucket_conflict_resolution::sequence_number;
+            {
+                auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+            }
+            {
+                auto bucket_exists = test::utils::wait_until([&bucket_name, &c]() {
+                    auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                    return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(bucket_exists);
+                auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                REQUIRE_SUCCESS(ctx.ec());
                 REQUIRE(bucket_settings.bucket_type == bucket.bucket_type);
                 REQUIRE(bucket_settings.name == bucket.name);
-                REQUIRE(bucket_settings.ram_quota_mb == bucket.ram_quota_mb);
-                old_quota_mb = bucket_settings.ram_quota_mb;
+                REQUIRE(Approx(bucket_settings.ram_quota_mb).margin(5) == bucket.ram_quota_mb);
                 REQUIRE(bucket_settings.num_replicas == bucket.num_replicas);
                 REQUIRE(bucket_settings.flush_enabled == bucket.flush_enabled);
                 REQUIRE(bucket_settings.max_expiry == bucket.max_expiry);
                 REQUIRE(bucket_settings.eviction_policy == bucket.eviction_policy);
                 REQUIRE(bucket_settings.compression_mode == bucket.compression_mode);
                 REQUIRE(bucket_settings.replica_indexes == bucket.replica_indexes);
-                break;
             }
-            REQUIRE(found);
+            std::uint64_t old_quota_mb{ 0 };
+            {
+                auto [ctx, buckets] = c.buckets().get_all_buckets({}).get();
+                INFO(ctx.content());
+                REQUIRE_SUCCESS(ctx.ec());
+                bool found = false;
+                for (const auto& bucket : buckets) {
+                    if (bucket.name != bucket_name) {
+                        continue;
+                    }
+                    found = true;
+                    REQUIRE(bucket_settings.bucket_type == bucket.bucket_type);
+                    REQUIRE(bucket_settings.name == bucket.name);
+                    REQUIRE(bucket_settings.ram_quota_mb == bucket.ram_quota_mb);
+                    old_quota_mb = bucket_settings.ram_quota_mb;
+                    REQUIRE(bucket_settings.num_replicas == bucket.num_replicas);
+                    REQUIRE(bucket_settings.flush_enabled == bucket.flush_enabled);
+                    REQUIRE(bucket_settings.max_expiry == bucket.max_expiry);
+                    REQUIRE(bucket_settings.eviction_policy == bucket.eviction_policy);
+                    REQUIRE(bucket_settings.compression_mode == bucket.compression_mode);
+                    REQUIRE(bucket_settings.replica_indexes == bucket.replica_indexes);
+                    break;
+                }
+                REQUIRE(found);
+            }
+
+            {
+                bucket_settings.ram_quota_mb = old_quota_mb + 20;
+                auto ctx = c.buckets().update_bucket(bucket_settings, {}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+            }
+            auto ram_quota_updated = test::utils::wait_until([&bucket_name, c, old_quota_mb]() {
+                auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                return !ctx.ec() && bucket.ram_quota_mb > old_quota_mb;
+            });
+            REQUIRE(ram_quota_updated);
+            {
+                auto ctx = c.buckets().drop_bucket(bucket_name, {}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+            }
+            {
+                auto bucket_not_found = test::utils::wait_until([&bucket_name, c]() {
+                    auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                    return ctx.ec() == couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(bucket_not_found);
+            }
+            {
+                auto [ctx, buckets] = c.buckets().get_all_buckets({}).get();
+                REQUIRE_SUCCESS(ctx.ec());
+                REQUIRE(!buckets.empty());
+                auto known_buckets =
+                  std::count_if(buckets.begin(), buckets.end(), [&bucket_name](auto& entry) { return entry.name == bucket_name; });
+                REQUIRE(known_buckets == 0);
+            }
         }
+    }
 
+    SECTION("flush")
+    {
+        SECTION("core api")
         {
-            bucket_settings.ram_quota_mb = old_quota_mb + 20;
-            couchbase::core::operations::management::bucket_update_request req;
-            req.bucket = bucket_settings;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_SUCCESS(resp.ctx.ec);
-        }
+            SECTION("flush item")
+            {
+                couchbase::core::document_id id{ bucket_name, "_default", "_default", test::utils::uniq_id("foo") };
 
-        auto ram_quota_updated = test::utils::wait_until([&integration, &bucket_name, old_quota_mb]() {
-            couchbase::core::operations::management::bucket_get_request req{ bucket_name };
-            auto resp = test::utils::execute(integration.cluster, req);
-            return !resp.ctx.ec && resp.bucket.ram_quota_mb > old_quota_mb;
-        });
-        REQUIRE(ram_quota_updated);
+                {
+                    couchbase::core::operations::management::bucket_create_request req;
+                    req.bucket.name = bucket_name;
+                    req.bucket.flush_enabled = true;
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                }
 
-        {
-            couchbase::core::operations::management::bucket_drop_request req{ bucket_name };
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_SUCCESS(resp.ctx.ec);
-        }
+                REQUIRE(test::utils::wait_until_bucket_healthy(integration.cluster, bucket_name));
 
-        {
-            couchbase::core::operations::management::bucket_get_request req{ bucket_name };
-            auto resp = retry_on_error(integration, req, {});
-            REQUIRE(resp.ctx.ec == couchbase::errc::common::bucket_not_found);
-        }
+                test::utils::open_bucket(integration.cluster, bucket_name);
 
-        {
-            couchbase::core::operations::management::bucket_get_all_request req;
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_SUCCESS(resp.ctx.ec);
-            REQUIRE(!resp.buckets.empty());
-            auto known_buckets =
-              std::count_if(resp.buckets.begin(), resp.buckets.end(), [&bucket_name](auto& entry) { return entry.name == bucket_name; });
-            REQUIRE(known_buckets == 0);
-        }
-    }
+                {
+                    const tao::json::value value = {
+                        { "a", 1.0 },
+                    };
+                    couchbase::core::operations::insert_request req{ id, couchbase::core::utils::json::generate_binary(value) };
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    REQUIRE_SUCCESS(resp.ctx.ec());
+                }
 
-    SECTION("flush")
-    {
-        SECTION("flush item")
-        {
-            couchbase::core::document_id id{ bucket_name, "_default", "_default", test::utils::uniq_id("foo") };
+                {
+                    couchbase::core::operations::get_request req{ id };
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    REQUIRE_SUCCESS(resp.ctx.ec());
+                }
+
+                {
+                    couchbase::core::operations::management::bucket_flush_request req{ bucket_name };
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                }
 
+                auto flushed = test::utils::wait_until([&integration, id]() {
+                    couchbase::core::operations::get_request req{ id };
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    return resp.ctx.ec() == couchbase::errc::key_value::document_not_found;
+                });
+                REQUIRE(flushed);
+            }
+            SECTION("no bucket")
             {
-                couchbase::core::operations::management::bucket_create_request req;
-                req.bucket.name = bucket_name;
-                req.bucket.flush_enabled = true;
+                couchbase::core::operations::management::bucket_flush_request req{ bucket_name };
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_SUCCESS(resp.ctx.ec);
+                REQUIRE(resp.ctx.ec == couchbase::errc::common::bucket_not_found);
             }
 
-            REQUIRE(test::utils::wait_until_bucket_healthy(integration.cluster, bucket_name));
+            SECTION("flush disabled")
+            {
+                {
+                    couchbase::core::operations::management::bucket_create_request req;
+                    req.bucket.name = bucket_name;
+                    req.bucket.flush_enabled = false;
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                }
 
-            test::utils::open_bucket(integration.cluster, bucket_name);
+                REQUIRE(test::utils::wait_until_bucket_healthy(integration.cluster, bucket_name));
 
+                {
+                    couchbase::core::operations::management::bucket_flush_request req{ bucket_name };
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    REQUIRE(resp.ctx.ec == couchbase::errc::management::bucket_not_flushable);
+                }
+            }
+        }
+        SECTION("public API")
+        {
+            couchbase::cluster c(integration.cluster);
+            SECTION("flush item")
             {
-                const tao::json::value value = {
-                    { "a", 1.0 },
-                };
-                couchbase::core::operations::insert_request req{ id, couchbase::core::utils::json::generate_binary(value) };
-                auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_SUCCESS(resp.ctx.ec());
+                auto id = test::utils::uniq_id("foo");
+
+                {
+                    couchbase::management::cluster::bucket_settings bucket_settings;
+                    bucket_settings.name = bucket_name;
+                    bucket_settings.flush_enabled = true;
+                    auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                }
+
+                REQUIRE(test::utils::wait_until_bucket_healthy(integration.cluster, bucket_name));
+
+                test::utils::open_bucket(integration.cluster, bucket_name);
+
+                auto default_coll = c.bucket(bucket_name).default_collection();
+                {
+                    const tao::json::value value = {
+                        { "a", 1.0 },
+                    };
+
+                    auto [ctx, resp] = default_coll.insert(id, value, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                }
+                {
+                    auto [ctx, resp] = default_coll.get(id, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                }
+                {
+                    auto ctx = c.buckets().flush_bucket(bucket_name, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                }
+                auto flushed = test::utils::wait_until([id, default_coll]() {
+                    auto [ctx, resp] = default_coll.get(id, {}).get();
+                    return ctx.ec() == couchbase::errc::key_value::document_not_found;
+                });
+                REQUIRE(flushed);
             }
 
+            SECTION("no bucket")
             {
-                couchbase::core::operations::get_request req{ id };
-                auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_SUCCESS(resp.ctx.ec());
+                auto ctx = c.buckets().flush_bucket(bucket_name, {}).get();
+                REQUIRE(ctx.ec() == couchbase::errc::common::bucket_not_found);
             }
 
+            SECTION("flush disabled")
             {
-                couchbase::core::operations::management::bucket_flush_request req{ bucket_name };
-                auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_SUCCESS(resp.ctx.ec);
-            }
+                {
+                    couchbase::management::cluster::bucket_settings bucket_settings;
+                    bucket_settings.name = bucket_name;
+                    bucket_settings.flush_enabled = false;
+                    auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                }
 
-            auto flushed = test::utils::wait_until([&integration, id]() {
-                couchbase::core::operations::get_request req{ id };
-                auto resp = test::utils::execute(integration.cluster, req);
-                return resp.ctx.ec() == couchbase::errc::key_value::document_not_found;
-            });
-            REQUIRE(flushed);
+                auto bucket_exists = test::utils::wait_until([&bucket_name, c]() {
+                    auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                    return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                });
+                REQUIRE(bucket_exists);
+
+                {
+                    auto ctx = c.buckets().flush_bucket(bucket_name, {}).get();
+                    REQUIRE(ctx.ec() == couchbase::errc::management::bucket_not_flushable);
+                }
+            }
         }
+    }
 
-        SECTION("no bucket")
+    if (integration.cluster_version().supports_memcached_buckets()) {
+        SECTION("memcached")
         {
-            couchbase::core::operations::management::bucket_flush_request req{ bucket_name };
-            auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::errc::common::bucket_not_found);
+            SECTION("core api")
+            {
+                {
+                    couchbase::core::management::cluster::bucket_settings bucket_settings;
+                    bucket_settings.name = bucket_name;
+                    bucket_settings.bucket_type = couchbase::core::management::cluster::bucket_type::memcached;
+                    bucket_settings.num_replicas = 0;
+                    couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                }
+
+                {
+                    auto resp = wait_for_bucket_created(integration, bucket_name);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                    REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::memcached);
+                }
+            }
+            SECTION("public api")
+            {
+                couchbase::cluster c(integration.cluster);
+                {
+                    couchbase::management::cluster::bucket_settings bucket_settings;
+                    bucket_settings.name = bucket_name;
+                    bucket_settings.bucket_type = couchbase::management::cluster::bucket_type::memcached;
+                    bucket_settings.num_replicas = 0;
+                    auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                }
+
+                {
+                    auto bucket_exists = test::utils::wait_until([&bucket_name, &c]() {
+                        auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                        return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                    });
+                    REQUIRE(bucket_exists);
+                    auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                    REQUIRE(bucket.bucket_type == couchbase::management::cluster::bucket_type::memcached);
+                }
+            }
         }
+    }
 
-        SECTION("flush disabled")
+    SECTION("ephemeral")
+    {
+        SECTION("core api")
         {
+            couchbase::core::management::cluster::bucket_settings bucket_settings;
+            bucket_settings.name = bucket_name;
+            bucket_settings.bucket_type = couchbase::core::management::cluster::bucket_type::ephemeral;
+
+            SECTION("default eviction")
             {
-                couchbase::core::operations::management::bucket_create_request req;
-                req.bucket.name = bucket_name;
-                req.bucket.flush_enabled = false;
-                auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_SUCCESS(resp.ctx.ec);
-            }
+                {
+                    couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                }
 
-            REQUIRE(test::utils::wait_until_bucket_healthy(integration.cluster, bucket_name));
+                {
+                    auto resp = wait_for_bucket_created(integration, bucket_name);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                    REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::ephemeral);
+                    REQUIRE(resp.bucket.eviction_policy == couchbase::core::management::cluster::bucket_eviction_policy::no_eviction);
+                }
+            }
 
+            SECTION("nru eviction")
             {
-                couchbase::core::operations::management::bucket_flush_request req{ bucket_name };
-                auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE(resp.ctx.ec == couchbase::errc::management::bucket_not_flushable);
+                {
+                    bucket_settings.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used;
+                    couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                }
+
+                {
+                    auto resp = wait_for_bucket_created(integration, bucket_name);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                    REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::ephemeral);
+                    REQUIRE(resp.bucket.eviction_policy == couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used);
+                }
             }
-        }
-    }
 
-    if (integration.cluster_version().supports_memcached_buckets()) {
-        SECTION("memcached")
+            if (integration.cluster_version().supports_storage_backend()) {
+                SECTION("storage backend")
+                {
+                    {
+                        bucket_settings.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::couchstore;
+                        couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
+                        auto resp = test::utils::execute(integration.cluster, req);
+                        REQUIRE_SUCCESS(resp.ctx.ec);
+                    }
+
+                    {
+                        auto resp = wait_for_bucket_created(integration, bucket_name);
+                        REQUIRE_SUCCESS(resp.ctx.ec);
+                        REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::ephemeral);
+                        REQUIRE(resp.bucket.storage_backend == couchbase::core::management::cluster::bucket_storage_backend::unknown);
+                    }
+                }
+            }
+        }
+        SECTION("public api")
         {
+            couchbase::cluster c(integration.cluster);
+            couchbase::management::cluster::bucket_settings bucket_settings;
+            bucket_settings.name = bucket_name;
+            bucket_settings.bucket_type = couchbase::management::cluster::bucket_type::ephemeral;
+
+            SECTION("default eviction")
             {
-                couchbase::core::management::cluster::bucket_settings bucket_settings;
-                bucket_settings.name = bucket_name;
-                bucket_settings.bucket_type = couchbase::core::management::cluster::bucket_type::memcached;
-                bucket_settings.num_replicas = 0;
-                couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
-                auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_SUCCESS(resp.ctx.ec);
+                {
+                    auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                }
+
+                {
+                    auto bucket_exists = test::utils::wait_until([&bucket_name, c]() {
+                        auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                        return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                    });
+                    REQUIRE(bucket_exists);
+                    auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                    REQUIRE(bucket.bucket_type == couchbase::management::cluster::bucket_type::ephemeral);
+                    REQUIRE(bucket.eviction_policy == couchbase::management::cluster::bucket_eviction_policy::no_eviction);
+                }
             }
 
+            SECTION("nru eviction")
             {
-                auto resp = wait_for_bucket_created(integration, bucket_name);
-                REQUIRE_SUCCESS(resp.ctx.ec);
-                REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::memcached);
+                {
+                    bucket_settings.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::not_recently_used;
+                    auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                }
+
+                {
+                    auto bucket_exists = test::utils::wait_until([&bucket_name, c]() {
+                        auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                        return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                    });
+                    REQUIRE(bucket_exists);
+                    auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                    REQUIRE(bucket.bucket_type == couchbase::management::cluster::bucket_type::ephemeral);
+                    REQUIRE(bucket.eviction_policy == couchbase::management::cluster::bucket_eviction_policy::not_recently_used);
+                }
+            }
+            if (integration.cluster_version().supports_storage_backend()) {
+                SECTION("storage backend")
+                {
+                    {
+                        bucket_settings.storage_backend = couchbase::management::cluster::bucket_storage_backend::couchstore;
+                        auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                        REQUIRE_SUCCESS(ctx.ec());
+                    }
+
+                    {
+                        auto bucket_exists = test::utils::wait_until([&bucket_name, c]() {
+                            auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                            return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                        });
+                        REQUIRE(bucket_exists);
+                        auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                        REQUIRE_SUCCESS(ctx.ec());
+                        REQUIRE(bucket.bucket_type == couchbase::management::cluster::bucket_type::ephemeral);
+                        REQUIRE(bucket.storage_backend == couchbase::management::cluster::bucket_storage_backend::unknown);
+                    }
+                }
             }
         }
     }
-
-    SECTION("ephemeral")
+    SECTION("couchbase")
     {
-        couchbase::core::management::cluster::bucket_settings bucket_settings;
-        bucket_settings.name = bucket_name;
-        bucket_settings.bucket_type = couchbase::core::management::cluster::bucket_type::ephemeral;
-
-        SECTION("default eviction")
+        SECTION("core api")
         {
-            {
-                couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
-                auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_SUCCESS(resp.ctx.ec);
-            }
+            couchbase::core::management::cluster::bucket_settings bucket_settings;
+            bucket_settings.name = bucket_name;
+            bucket_settings.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
 
+            SECTION("default eviction")
             {
-                auto resp = wait_for_bucket_created(integration, bucket_name);
-                REQUIRE_SUCCESS(resp.ctx.ec);
-                REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::ephemeral);
-                REQUIRE(resp.bucket.eviction_policy == couchbase::core::management::cluster::bucket_eviction_policy::no_eviction);
-            }
-        }
+                {
 
-        SECTION("nru eviction")
-        {
-            {
-                bucket_settings.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used;
-                couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
-                auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_SUCCESS(resp.ctx.ec);
-            }
+                    couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                }
 
-            {
-                auto resp = wait_for_bucket_created(integration, bucket_name);
-                REQUIRE_SUCCESS(resp.ctx.ec);
-                REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::ephemeral);
-                REQUIRE(resp.bucket.eviction_policy == couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used);
+                {
+                    auto resp = wait_for_bucket_created(integration, bucket_name);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                    REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::couchbase);
+                    REQUIRE(resp.bucket.eviction_policy == couchbase::core::management::cluster::bucket_eviction_policy::value_only);
+                }
             }
-        }
 
-        if (integration.cluster_version().supports_storage_backend()) {
-            SECTION("storage backend")
+            SECTION("full eviction")
             {
                 {
-                    bucket_settings.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::couchstore;
+                    bucket_settings.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::full;
                     couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
                     auto resp = test::utils::execute(integration.cluster, req);
                     REQUIRE_SUCCESS(resp.ctx.ec);
@@ -316,88 +631,144 @@ TEST_CASE("integration: bucket management", "[integration]")
                 {
                     auto resp = wait_for_bucket_created(integration, bucket_name);
                     REQUIRE_SUCCESS(resp.ctx.ec);
-                    REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::ephemeral);
-                    REQUIRE(resp.bucket.storage_backend == couchbase::core::management::cluster::bucket_storage_backend::unknown);
+                    REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::couchbase);
+                    REQUIRE(resp.bucket.eviction_policy == couchbase::core::management::cluster::bucket_eviction_policy::full);
                 }
             }
-        }
-    }
-
-    SECTION("couchbase")
-    {
-        couchbase::core::management::cluster::bucket_settings bucket_settings;
-        bucket_settings.name = bucket_name;
-        bucket_settings.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
 
-        SECTION("default eviction")
-        {
-            {
-
-                couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
-                auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_SUCCESS(resp.ctx.ec);
-            }
+            if (integration.cluster_version().supports_storage_backend()) {
+                SECTION("storage backend")
+                {
+                    SECTION("couchstore")
+                    {
+                        {
+                            bucket_settings.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::couchstore;
+                            couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
+                            auto resp = test::utils::execute(integration.cluster, req);
+                            REQUIRE_SUCCESS(resp.ctx.ec);
+                        }
+
+                        {
+                            auto resp = wait_for_bucket_created(integration, bucket_name);
+                            REQUIRE_SUCCESS(resp.ctx.ec);
+                            REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::couchbase);
+                            REQUIRE(resp.bucket.storage_backend ==
+                                    couchbase::core::management::cluster::bucket_storage_backend::couchstore);
+                        }
+                    }
 
-            {
-                auto resp = wait_for_bucket_created(integration, bucket_name);
-                REQUIRE_SUCCESS(resp.ctx.ec);
-                REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::couchbase);
-                REQUIRE(resp.bucket.eviction_policy == couchbase::core::management::cluster::bucket_eviction_policy::value_only);
+                    SECTION("magma")
+                    {
+                        {
+                            bucket_settings.ram_quota_mb = integration.cluster_version().is_neo() ? 1'024 : 256;
+                            bucket_settings.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::magma;
+                            couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
+                            auto resp = test::utils::execute(integration.cluster, req);
+                            REQUIRE_SUCCESS(resp.ctx.ec);
+                        }
+
+                        {
+                            auto resp = wait_for_bucket_created(integration, bucket_name);
+                            REQUIRE_SUCCESS(resp.ctx.ec);
+                            REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::couchbase);
+                            REQUIRE(resp.bucket.storage_backend == couchbase::core::management::cluster::bucket_storage_backend::magma);
+                        }
+                    }
+                }
             }
         }
-
-        SECTION("full eviction")
+        SECTION("public api")
         {
-            {
-                bucket_settings.eviction_policy = couchbase::core::management::cluster::bucket_eviction_policy::full;
-                couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
-                auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_SUCCESS(resp.ctx.ec);
-            }
+            couchbase::cluster c(integration.cluster);
+            couchbase::management::cluster::bucket_settings bucket_settings;
+            bucket_settings.name = bucket_name;
+            bucket_settings.bucket_type = couchbase::management::cluster::bucket_type::couchbase;
 
+            SECTION("default eviction")
             {
-                auto resp = wait_for_bucket_created(integration, bucket_name);
-                REQUIRE_SUCCESS(resp.ctx.ec);
-                REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::couchbase);
-                REQUIRE(resp.bucket.eviction_policy == couchbase::core::management::cluster::bucket_eviction_policy::full);
+                {
+                    auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                }
+
+                {
+                    auto bucket_exists = test::utils::wait_until([&bucket_name, c]() {
+                        auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                        return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                    });
+                    REQUIRE(bucket_exists);
+                    auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                    REQUIRE(bucket.bucket_type == couchbase::management::cluster::bucket_type::couchbase);
+                    REQUIRE(bucket.eviction_policy == couchbase::management::cluster::bucket_eviction_policy::value_only);
+                }
             }
-        }
 
-        if (integration.cluster_version().supports_storage_backend()) {
-            SECTION("storage backend")
+            SECTION("full eviction")
             {
-                SECTION("couchstore")
                 {
-                    {
-                        bucket_settings.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::couchstore;
-                        couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
-                        auto resp = test::utils::execute(integration.cluster, req);
-                        REQUIRE_SUCCESS(resp.ctx.ec);
-                    }
+                    bucket_settings.eviction_policy = couchbase::management::cluster::bucket_eviction_policy::full;
+                    auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                }
 
-                    {
-                        auto resp = wait_for_bucket_created(integration, bucket_name);
-                        REQUIRE_SUCCESS(resp.ctx.ec);
-                        REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::couchbase);
-                        REQUIRE(resp.bucket.storage_backend == couchbase::core::management::cluster::bucket_storage_backend::couchstore);
-                    }
+                {
+                    auto bucket_exists = test::utils::wait_until([&bucket_name, c]() {
+                        auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                        return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                    });
+                    REQUIRE(bucket_exists);
+                    auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                    REQUIRE_SUCCESS(ctx.ec());
+                    REQUIRE(bucket.bucket_type == couchbase::management::cluster::bucket_type::couchbase);
+                    REQUIRE(bucket.eviction_policy == couchbase::management::cluster::bucket_eviction_policy::full);
                 }
+            }
 
-                SECTION("magma")
+            if (integration.cluster_version().supports_storage_backend()) {
+                SECTION("storage backend")
                 {
+                    SECTION("couchstore")
                     {
-                        bucket_settings.ram_quota_mb = integration.cluster_version().is_neo() ? 1'024 : 256;
-                        bucket_settings.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::magma;
-                        couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
-                        auto resp = test::utils::execute(integration.cluster, req);
-                        REQUIRE_SUCCESS(resp.ctx.ec);
+                        {
+                            bucket_settings.storage_backend = couchbase::management::cluster::bucket_storage_backend::couchstore;
+                            auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                            REQUIRE_SUCCESS(ctx.ec());
+                        }
+
+                        {
+                            auto bucket_exists = test::utils::wait_until([&bucket_name, c]() {
+                                auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                                return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                            });
+                            REQUIRE(bucket_exists);
+                            auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                            REQUIRE_SUCCESS(ctx.ec());
+                            REQUIRE(bucket.bucket_type == couchbase::management::cluster::bucket_type::couchbase);
+                            REQUIRE(bucket.storage_backend == couchbase::management::cluster::bucket_storage_backend::couchstore);
+                        }
                     }
 
+                    SECTION("magma")
                     {
-                        auto resp = wait_for_bucket_created(integration, bucket_name);
-                        REQUIRE_SUCCESS(resp.ctx.ec);
-                        REQUIRE(resp.bucket.bucket_type == couchbase::core::management::cluster::bucket_type::couchbase);
-                        REQUIRE(resp.bucket.storage_backend == couchbase::core::management::cluster::bucket_storage_backend::magma);
+                        {
+                            bucket_settings.ram_quota_mb = integration.cluster_version().is_neo() ? 1'024 : 256;
+                            bucket_settings.storage_backend = couchbase::management::cluster::bucket_storage_backend::magma;
+                            auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                            REQUIRE_SUCCESS(ctx.ec());
+                        }
+
+                        {
+                            auto bucket_exists = test::utils::wait_until([&bucket_name, c]() {
+                                auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                                return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                            });
+                            REQUIRE(bucket_exists);
+                            auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                            REQUIRE_SUCCESS(ctx.ec());
+                            REQUIRE(bucket.bucket_type == couchbase::management::cluster::bucket_type::couchbase);
+                            REQUIRE(bucket.storage_backend == couchbase::management::cluster::bucket_storage_backend::magma);
+                        }
                     }
                 }
             }
@@ -406,41 +777,36 @@ TEST_CASE("integration: bucket management", "[integration]")
 
     SECTION("update no bucket")
     {
-
-        couchbase::core::management::cluster::bucket_settings bucket_settings;
-        bucket_settings.name = bucket_name;
-        couchbase::core::operations::management::bucket_update_request req;
-        req.bucket = bucket_settings;
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::errc::common::bucket_not_found);
+        SECTION("core api")
+        {
+            couchbase::core::management::cluster::bucket_settings bucket_settings;
+            bucket_settings.name = bucket_name;
+            couchbase::core::operations::management::bucket_update_request req;
+            req.bucket = bucket_settings;
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::bucket_not_found);
+        }
+        SECTION("public api")
+        {
+            couchbase::cluster c(integration.cluster);
+            couchbase::management::cluster::bucket_settings bucket_settings;
+            bucket_settings.name = bucket_name;
+            auto ctx = c.buckets().update_bucket(bucket_settings, {}).get();
+            REQUIRE(ctx.ec() == couchbase::errc::common::bucket_not_found);
+        }
     }
 
     if (integration.cluster_version().supports_minimum_durability_level()) {
         SECTION("minimum durability level")
         {
-            couchbase::core::management::cluster::bucket_settings bucket_settings;
-            bucket_settings.name = bucket_name;
-
-            SECTION("default")
+            SECTION("core api")
             {
-                {
-                    couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
-                    auto resp = test::utils::execute(integration.cluster, req);
-                    REQUIRE_SUCCESS(resp.ctx.ec);
-                }
-
-                {
-                    auto resp = wait_for_bucket_created(integration, bucket_name);
-                    REQUIRE_SUCCESS(resp.ctx.ec);
-                    REQUIRE(resp.bucket.minimum_durability_level == couchbase::durability_level::none);
-                }
-            }
+                couchbase::core::management::cluster::bucket_settings bucket_settings;
+                bucket_settings.name = bucket_name;
 
-            if (integration.number_of_nodes() >= 2) {
-                SECTION("majority")
+                SECTION("default")
                 {
                     {
-                        bucket_settings.minimum_durability_level = couchbase::durability_level::majority;
                         couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
                         auto resp = test::utils::execute(integration.cluster, req);
                         REQUIRE_SUCCESS(resp.ctx.ec);
@@ -449,7 +815,70 @@ TEST_CASE("integration: bucket management", "[integration]")
                     {
                         auto resp = wait_for_bucket_created(integration, bucket_name);
                         REQUIRE_SUCCESS(resp.ctx.ec);
-                        REQUIRE(resp.bucket.minimum_durability_level == couchbase::durability_level::majority);
+                        REQUIRE(resp.bucket.minimum_durability_level == couchbase::durability_level::none);
+                    }
+                }
+
+                if (integration.number_of_nodes() >= 2) {
+                    SECTION("majority")
+                    {
+                        {
+                            bucket_settings.minimum_durability_level = couchbase::durability_level::majority;
+                            couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
+                            auto resp = test::utils::execute(integration.cluster, req);
+                            REQUIRE_SUCCESS(resp.ctx.ec);
+                        }
+
+                        {
+                            auto resp = wait_for_bucket_created(integration, bucket_name);
+                            REQUIRE_SUCCESS(resp.ctx.ec);
+                            REQUIRE(resp.bucket.minimum_durability_level == couchbase::durability_level::majority);
+                        }
+                    }
+                }
+            }
+            SECTION("public api")
+            {
+                couchbase::cluster c(integration.cluster);
+                couchbase::management::cluster::bucket_settings bucket_settings;
+                bucket_settings.name = bucket_name;
+
+                SECTION("default")
+                {
+                    {
+                        auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                        REQUIRE_SUCCESS(ctx.ec());
+                    }
+                    {
+                        auto bucket_exists = test::utils::wait_until([&bucket_name, c]() {
+                            auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                            return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                        });
+                        REQUIRE(bucket_exists);
+                        auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                        REQUIRE_SUCCESS(ctx.ec());
+                        REQUIRE(bucket.minimum_durability_level == couchbase::durability_level::none);
+                    }
+                }
+                if (integration.number_of_nodes() >= 2) {
+                    SECTION("majority")
+                    {
+                        {
+                            bucket_settings.minimum_durability_level = couchbase::durability_level::majority;
+                            auto ctx = c.buckets().create_bucket(bucket_settings, {}).get();
+                            REQUIRE_SUCCESS(ctx.ec());
+                        }
+
+                        {
+                            auto bucket_exists = test::utils::wait_until([&bucket_name, c]() {
+                                auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                                return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                            });
+                            REQUIRE(bucket_exists);
+                            auto [ctx, bucket] = c.buckets().get_bucket(bucket_name, {}).get();
+                            REQUIRE_SUCCESS(ctx.ec());
+                            REQUIRE(bucket.minimum_durability_level == couchbase::durability_level::majority);
+                        }
                     }
                 }
             }
@@ -508,7 +937,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 +1077,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 +1288,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 +1386,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");
@@ -1027,12 +1461,22 @@ TEST_CASE("integration: user management collections roles", "[integration]")
         REQUIRE(resp.user.roles[0].scope == scope_name);
         REQUIRE(resp.user.roles[0].collection == collection_name);
     }
+
+    {
+        couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+    }
 }
 
 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 +1884,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");
@@ -1483,7 +1930,8 @@ TEST_CASE("integration: collections query index management", "[integration]")
                     req.collection_name = collection_name;
                     req.is_primary = true;
                     resp = test::utils::execute(integration.cluster, req);
-                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found;
+                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found &&
+                           resp.ctx.ec != couchbase::errc::common::scope_not_found;
                 });
                 REQUIRE(operation_completed);
                 REQUIRE_SUCCESS(resp.ctx.ec);
@@ -1508,7 +1956,7 @@ TEST_CASE("integration: collections query index management", "[integration]")
                 bool operation_completed = test::utils::wait_until([&manager, &ec]() {
                     auto ctx = manager.create_primary_index({}).get();
                     ec = ctx.ec();
-                    return ctx.ec() != couchbase::errc::common::bucket_not_found;
+                    return ec != couchbase::errc::common::bucket_not_found && ec != couchbase::errc::common::scope_not_found;
                 });
 
                 REQUIRE(operation_completed);
@@ -1538,7 +1986,8 @@ TEST_CASE("integration: collections query index management", "[integration]")
                     req.index_name = index_name;
                     req.is_primary = true;
                     resp = test::utils::execute(integration.cluster, req);
-                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found;
+                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found &&
+                           resp.ctx.ec != couchbase::errc::common::scope_not_found;
                 });
                 REQUIRE(operation_completed);
                 REQUIRE_SUCCESS(resp.ctx.ec);
@@ -1612,7 +2061,8 @@ TEST_CASE("integration: collections query index management", "[integration]")
                     req.collection_name = collection_name;
                     req.fields = { "field" };
                     resp = test::utils::execute(integration.cluster, req);
-                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found;
+                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found &&
+                           resp.ctx.ec != couchbase::errc::common::scope_not_found;
                 });
                 REQUIRE(operation_completed);
                 REQUIRE_SUCCESS(resp.ctx.ec);
@@ -1765,7 +2215,8 @@ TEST_CASE("integration: collections query index management", "[integration]")
                     req.fields = { "field" };
                     req.deferred = true;
                     resp = test::utils::execute(integration.cluster, req);
-                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found;
+                    return resp.ctx.ec != couchbase::errc::common::bucket_not_found &&
+                           resp.ctx.ec != couchbase::errc::common::scope_not_found;
                 });
                 REQUIRE(operation_completed);
                 REQUIRE_SUCCESS(resp.ctx.ec);
@@ -1938,31 +2389,34 @@ TEST_CASE("integration: collections query index management", "[integration]")
                       .ec() == couchbase::errc::common::ambiguous_timeout);
         }
     }
-    SECTION("watch missing collection")
-    {
-        SECTION("public API")
-        {
-            couchbase::cluster c(integration.cluster);
-            auto coll = c.bucket(integration.ctx.bucket).scope(scope_name).collection("missing_collection");
-            REQUIRE(coll.query_indexes()
-                      .watch_indexes({ index_name }, couchbase::watch_query_indexes_options().timeout(std::chrono::seconds(5)))
-                      .get()
-                      .ec() == couchbase::errc::common::ambiguous_timeout);
-        }
-    }
+    SECTION("watch missing collection"){ SECTION("public API"){ couchbase::cluster c(integration.cluster);
+    auto coll = c.bucket(integration.ctx.bucket).scope(scope_name).collection("missing_collection");
+    REQUIRE(coll.query_indexes()
+              .watch_indexes({ index_name }, couchbase::watch_query_indexes_options().timeout(std::chrono::seconds(5)))
+              .get()
+              .ec() == couchbase::errc::common::ambiguous_timeout);
+}
+}
+
+{
+    couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+    auto resp = test::utils::execute(integration.cluster, req);
+    REQUIRE_SUCCESS(resp.ctx.ec);
+}
 }
 
 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 +2942,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);
@@ -2578,6 +3034,12 @@ TEST_CASE("integration: analytics external link management", "[integration]")
                     run_azure_link_test(integration, dataverse_name, link_name);
                 }
             }
+
+            {
+                couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+                auto resp = test::utils::execute(integration.cluster, req);
+                REQUIRE_SUCCESS(resp.ctx.ec);
+            }
         }
     }
 }
@@ -2589,6 +3051,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);
     }
@@ -2639,7 +3105,7 @@ TEST_CASE("integration: search index management", "[integration]")
             if (integration.cluster_version().is_serverless_config_profile()) {
                 index.plan_params_json = serverless_plan_params;
             }
-            index.params_json = R"({ "store": { "indexType": "upside_down", "kvStoreName": "moss" }})";
+            index.params_json = R"({ "store": { "kvStoreName": "moss" }})";
             couchbase::core::operations::management::search_index_upsert_request req{};
             req.index = index;
             auto resp = test::utils::execute(integration.cluster, req);
@@ -2880,8 +3346,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");
@@ -2932,25 +3402,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";
@@ -2965,6 +3444,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";
@@ -2973,30 +3456,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")
@@ -3010,48 +3495,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());
     }
 }
 
@@ -3094,8 +3590,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()) {