couchbase 3.4.3 → 3.4.5

data/ext/couchbase/test/test_integration_management.cxx

@@ -74,244 +74,366 @@ 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;
-
-        {
-            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);
-        }
-        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);
-        }
-    }
-
-    SECTION("flush")
-    {
-        SECTION("flush item")
+        SECTION("core API")
         {
-            couchbase::core::document_id id{ bucket_name, "_default", "_default", test::utils::uniq_id("foo") };
-
+            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.name = bucket_name;
-                req.bucket.flush_enabled = true;
+                req.bucket = 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));
-
-            test::utils::open_bucket(integration.cluster, bucket_name);
+            {
+                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);
+            }
 
             {
-                const tao::json::value value = {
-                    { "a", 1.0 },
-                };
-                couchbase::core::operations::insert_request req{ id, couchbase::core::utils::json::generate_binary(value) };
+                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());
+                REQUIRE(resp.ctx.ec == couchbase::errc::management::bucket_exists);
             }
 
+            std::uint64_t old_quota_mb{ 0 };
             {
-                couchbase::core::operations::get_request req{ id };
+                couchbase::core::operations::management::bucket_get_all_request req{};
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE_SUCCESS(resp.ctx.ec());
+                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);
             }
 
             {
-                couchbase::core::operations::management::bucket_flush_request req{ bucket_name };
+                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 flushed = test::utils::wait_until([&integration, id]() {
-                couchbase::core::operations::get_request req{ id };
+            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() == couchbase::errc::key_value::document_not_found;
+                return !resp.ctx.ec && resp.bucket.ram_quota_mb > old_quota_mb;
             });
-            REQUIRE(flushed);
-        }
-
-        SECTION("no bucket")
-        {
-            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);
-        }
+            REQUIRE(ram_quota_updated);
 
-        SECTION("flush disabled")
-        {
             {
-                couchbase::core::operations::management::bucket_create_request req;
-                req.bucket.name = bucket_name;
-                req.bucket.flush_enabled = false;
+                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);
+            }
 
             {
-                couchbase::core::operations::management::bucket_flush_request req{ bucket_name };
+                couchbase::core::operations::management::bucket_get_all_request req;
                 auto resp = test::utils::execute(integration.cluster, req);
-                REQUIRE(resp.ctx.ec == couchbase::errc::management::bucket_not_flushable);
+                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);
             }
         }
-    }
-
-    if (integration.cluster_version().supports_memcached_buckets()) {
-        SECTION("memcached")
+        SECTION("public API")
         {
+            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());
+            }
             {
-                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 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(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);
+            }
+            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);
             }
 
             {
-                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.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("ephemeral")
+    SECTION("flush")
     {
-        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")
         {
+            SECTION("flush item")
             {
-                couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
+                couchbase::core::document_id id{ bucket_name, "_default", "_default", test::utils::uniq_id("foo") };
+
+                {
+                    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);
+                }
+
+                REQUIRE(test::utils::wait_until_bucket_healthy(integration.cluster, bucket_name));
+
+                test::utils::open_bucket(integration.cluster, bucket_name);
+
+                {
+                    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());
+                }
+
+                {
+                    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_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);
             }
 
+            SECTION("flush disabled")
             {
-                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);
+                {
+                    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);
+                }
+
+                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("nru eviction")
+        SECTION("public API")
         {
+            couchbase::cluster c(integration.cluster);
+            SECTION("flush item")
             {
-                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 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")
             {
-                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 ctx = c.buckets().flush_bucket(bucket_name, {}).get();
+                REQUIRE(ctx.ec() == couchbase::errc::common::bucket_not_found);
+            }
+
+            SECTION("flush disabled")
+            {
+                {
+                    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 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);
+                }
             }
         }
+    }
 
-        if (integration.cluster_version().supports_storage_backend()) {
-            SECTION("storage backend")
+    if (integration.cluster_version().supports_memcached_buckets()) {
+        SECTION("memcached")
+        {
+            SECTION("core api")
             {
                 {
-                    bucket_settings.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::couchstore;
+                    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);
@@ -320,57 +442,78 @@ 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::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("couchbase")
+    SECTION("ephemeral")
     {
-        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")
+        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::ephemeral;
 
+            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::value_only);
-            }
-        }
+                {
+                    couchbase::core::operations::management::bucket_create_request req{ bucket_settings };
+                    auto resp = test::utils::execute(integration.cluster, req);
+                    REQUIRE_SUCCESS(resp.ctx.ec);
+                }
 
-        SECTION("full eviction")
-        {
-            {
-                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);
+                {
+                    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")
             {
-                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);
+                {
+                    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_storage_backend()) {
-            SECTION("storage backend")
-            {
-                SECTION("couchstore")
+            if (integration.cluster_version().supports_storage_backend()) {
+                SECTION("storage backend")
                 {
                     {
                         bucket_settings.storage_backend = couchbase::core::management::cluster::bucket_storage_backend::couchstore;
@@ -382,52 +525,95 @@ 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::couchbase);
-                        REQUIRE(resp.bucket.storage_backend == couchbase::core::management::cluster::bucket_storage_backend::couchstore);
+                        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")
+            {
+                {
+                    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")
+            {
+                {
+                    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());
+                }
 
-                SECTION("magma")
+                {
+                    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.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 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);
+                        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("update no bucket")
+    SECTION("couchbase")
     {
-
-        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);
-    }
-
-    if (integration.cluster_version().supports_minimum_durability_level()) {
-        SECTION("minimum durability level")
+        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::couchbase;
 
-            SECTION("default")
+            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);
@@ -436,15 +622,199 @@ 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::none);
+                    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.number_of_nodes() >= 2) {
-                SECTION("majority")
+            SECTION("full eviction")
+            {
+                {
+                    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);
+                }
+
+                {
+                    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);
+                }
+            }
+
+            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);
+                        }
+                    }
+
+                    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("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::couchbase;
+
+            SECTION("default eviction")
+            {
+                {
+                    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);
+                }
+            }
+
+            SECTION("full eviction")
+            {
+                {
+                    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 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);
+                }
+            }
+
+            if (integration.cluster_version().supports_storage_backend()) {
+                SECTION("storage backend")
+                {
+                    SECTION("couchstore")
+                    {
+                        {
+                            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")
+                    {
+                        {
+                            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);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    SECTION("update no bucket")
+    {
+        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")
+        {
+            SECTION("core api")
+            {
+                couchbase::core::management::cluster::bucket_settings bucket_settings;
+                bucket_settings.name = bucket_name;
+
+                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);
@@ -453,7 +823,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);
+                        }
                     }
                 }
             }
@@ -469,6 +902,86 @@ TEST_CASE("integration: bucket management", "[integration]")
     }
 }
 
+TEST_CASE("integration: bucket management history", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+
+    if (!integration.cluster_version().supports_bucket_management()) {
+        SKIP("cluster does not support bucket management");
+    }
+
+    if (!integration.cluster_version().supports_gcccp()) {
+        test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+    }
+
+    if (!integration.cluster_version().supports_bucket_history()) {
+        SKIP("cluster does not support bucket history");
+    }
+
+    auto bucket_name = test::utils::uniq_id("bucket");
+    auto update_bucket_name = test::utils::uniq_id("bucket");
+
+    SECTION("create history")
+    {
+        {
+            couchbase::core::management::cluster::bucket_settings bucket_settings;
+            bucket_settings.name = bucket_name;
+            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;
+            bucket_settings.history_retention_collection_default = true;
+            bucket_settings.history_retention_bytes = 2147483648;
+            bucket_settings.history_retention_duration = 13000;
+            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.storage_backend == couchbase::core::management::cluster::bucket_storage_backend::magma);
+            REQUIRE(resp.bucket.history_retention_collection_default == true);
+            REQUIRE(resp.bucket.history_retention_duration == 13000);
+            REQUIRE(resp.bucket.history_retention_bytes == 2147483648);
+        }
+    }
+
+    SECTION("update history")
+    {
+        couchbase::core::management::cluster::bucket_settings bucket_settings;
+        bucket_settings.ram_quota_mb = integration.cluster_version().is_neo() ? 1'024 : 256;
+        bucket_settings.name = update_bucket_name;
+        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 get_resp = wait_for_bucket_created(integration, update_bucket_name);
+            REQUIRE_SUCCESS(get_resp.ctx.ec);
+        }
+        {
+            bucket_settings.history_retention_collection_default = true;
+            bucket_settings.history_retention_bytes = 2147483648;
+            bucket_settings.history_retention_duration = 13000;
+            couchbase::core::operations::management::bucket_update_request req{ bucket_settings };
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_SUCCESS(resp.ctx.ec);
+            auto get_resp = wait_for_bucket_created(integration, update_bucket_name);
+            REQUIRE_SUCCESS(get_resp.ctx.ec);
+            REQUIRE(get_resp.bucket.storage_backend == couchbase::core::management::cluster::bucket_storage_backend::magma);
+            REQUIRE(get_resp.bucket.history_retention_collection_default == true);
+            REQUIRE(get_resp.bucket.history_retention_duration == 13000);
+            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 };
+        test::utils::execute(integration.cluster, req);
+        test::utils::execute(integration.cluster, update_req);
+    }
+}
+
 std::optional<couchbase::core::topology::collections_manifest::collection>
 get_collection(std::shared_ptr<couchbase::core::cluster> cluster,
                const std::string& bucket_name,
@@ -518,7 +1031,208 @@ TEST_CASE("integration: collection management", "[integration]")
     auto scope_name = test::utils::uniq_id("scope");
     auto collection_name = test::utils::uniq_id("collection");
     std::uint32_t max_expiry = 5;
+    SECTION("core api")
+    {
+        {
+            couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_SUCCESS(resp.ctx.ec);
+            auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+            REQUIRE(created);
+        }
+
+        {
+            auto created = test::utils::wait_until([&]() { return scope_exists(integration.cluster, integration.ctx.bucket, scope_name); });
+            REQUIRE(created);
+        }
+
+        {
+            couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE(resp.ctx.ec == couchbase::errc::management::scope_exists);
+        }
+
+        {
+            couchbase::core::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
+            if (integration.cluster_version().is_enterprise()) {
+                req.max_expiry = max_expiry;
+            }
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_SUCCESS(resp.ctx.ec);
+            auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+            REQUIRE(created);
+        }
+
+        {
+            couchbase::core::topology::collections_manifest::collection collection;
+            auto created = test::utils::wait_until([&]() {
+                auto coll = get_collection(integration.cluster, integration.ctx.bucket, scope_name, collection_name);
+                if (coll) {
+                    collection = *coll;
+                    return true;
+                }
+                return false;
+            });
+            REQUIRE(created);
+            if (integration.cluster_version().is_enterprise()) {
+                REQUIRE(collection.max_expiry == max_expiry);
+            }
+        }
+
+        {
+            couchbase::core::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE(resp.ctx.ec == couchbase::errc::management::collection_exists);
+        }
+        {
+            couchbase::core::operations::management::collection_drop_request req{ integration.ctx.bucket, scope_name, collection_name };
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_SUCCESS(resp.ctx.ec);
+        }
+
+        {
+            auto dropped = test::utils::wait_until(
+              [&]() { return !get_collection(integration.cluster, integration.ctx.bucket, scope_name, collection_name).has_value(); });
+            REQUIRE(dropped);
+        }
+
+        {
+            couchbase::core::operations::management::collection_drop_request req{ integration.ctx.bucket, scope_name, collection_name };
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::collection_not_found);
+        }
+
+        {
+            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);
+        }
+
+        {
+            auto dropped =
+              test::utils::wait_until([&]() { return !scope_exists(integration.cluster, integration.ctx.bucket, scope_name); });
+            REQUIRE(dropped);
+        }
+
+        {
+            couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE(resp.ctx.ec == couchbase::errc::common::scope_not_found);
+        }
+    }
+    SECTION("public API")
+    {
+        couchbase::cluster c(integration.cluster);
+        auto manager = c.bucket(integration.ctx.bucket).collections();
+        {
+            auto ctx = manager.create_scope(scope_name).get();
+            REQUIRE_SUCCESS(ctx.ec());
+        }
+        {
+            auto scope_exists = test::utils::wait_until([&scope_name, &manager]() {
+                auto [ctx, result] = manager.get_all_scopes().get();
+                if (!ctx.ec()) {
+                    for (auto& scope : result) {
+                        if (scope.name == scope_name) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            });
+            REQUIRE(scope_exists);
+        }
+        {
+            auto ctx = manager.create_scope(scope_name).get();
+            REQUIRE(ctx.ec() == couchbase::errc::management::scope_exists);
+        }
+        {
+            couchbase::create_collection_settings settings{};
+            if (integration.cluster_version().is_enterprise()) {
+                settings.max_expiry = max_expiry;
+            }
+            auto ctx = manager.create_collection(scope_name, collection_name, settings).get();
+            REQUIRE_SUCCESS(ctx.ec());
+            auto created = test::utils::wait_until([&scope_name, &collection_name, &manager]() {
+                auto [get_ctx, result] = manager.get_all_scopes().get();
+                if (!get_ctx.ec()) {
+                    for (auto& scope : result) {
+                        if (scope.name == scope_name) {
+                            for (auto& collection : scope.collections) {
+                                if (collection.name == collection_name) {
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                }
+                return false;
+            });
+            REQUIRE(created);
+        }
+        {
+            auto [ctx, scopes] = manager.get_all_scopes().get();
+            REQUIRE_SUCCESS(ctx.ec());
+            couchbase::management::bucket::collection_spec spec;
+            for (auto& scope : scopes) {
+                if (scope.name == scope_name) {
+                    for (auto& collection : scope.collections) {
+                        if (collection.name == collection_name) {
+                            spec = collection;
+                        }
+                    }
+                }
+            }
+            if (integration.cluster_version().is_enterprise()) {
+                REQUIRE(spec.max_expiry == max_expiry);
+            }
+        }
+        {
+            couchbase::create_collection_settings settings{};
+            auto ctx = manager.create_collection(scope_name, collection_name, settings).get();
+            REQUIRE(ctx.ec() == couchbase::errc::management::collection_exists);
+        }
+        {
+            auto ctx = manager.drop_collection(scope_name, collection_name).get();
+            REQUIRE_SUCCESS(ctx.ec());
+        }
+        {
+            auto bucket_name = integration.ctx.bucket;
+            auto does_not_exist = test::utils::wait_until([&scope_name, &collection_name, &manager]() {
+                auto ctx = manager.drop_collection(scope_name, collection_name).get();
+                return (ctx.ec() == couchbase::errc::common::collection_not_found);
+            });
+            REQUIRE(does_not_exist);
+        }
+        {
+            auto ctx = manager.drop_scope(scope_name).get();
+            REQUIRE_SUCCESS(ctx.ec());
+        }
+        {
+            auto does_not_exist = test::utils::wait_until([&scope_name, &manager]() {
+                auto ctx = manager.drop_scope(scope_name).get();
+                return (ctx.ec() == couchbase::errc::common::scope_not_found);
+            });
+            REQUIRE(does_not_exist);
+        }
+    }
+}
+
+TEST_CASE("integration: collection management bucket dedup", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    if (!integration.cluster_version().supports_collections()) {
+        SKIP("cluster does not support collections");
+    }
+    if (!integration.has_bucket_capability("nonDedupedHistory")) {
+        SKIP("Bucket does not support non deduped history");
+    }
 
+    auto bucket_name = test::utils::uniq_id("bucket");
+    auto scope_name = test::utils::uniq_id("scope");
+    auto collection_name = test::utils::uniq_id("collection");
     {
         couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
@@ -532,23 +1246,14 @@ TEST_CASE("integration: collection management", "[integration]")
         REQUIRE(created);
     }
 
-    {
-        couchbase::core::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::errc::management::scope_exists);
-    }
-
     {
         couchbase::core::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
-        if (integration.cluster_version().is_enterprise()) {
-            req.max_expiry = max_expiry;
-        }
+        req.history = true;
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec);
         auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
         REQUIRE(created);
     }
-
     {
         couchbase::core::topology::collections_manifest::collection collection;
         auto created = test::utils::wait_until([&]() {
@@ -560,50 +1265,27 @@ TEST_CASE("integration: collection management", "[integration]")
             return false;
         });
         REQUIRE(created);
-        if (integration.cluster_version().is_enterprise()) {
-            REQUIRE(collection.max_expiry == max_expiry);
-        }
-    }
-
-    {
-        couchbase::core::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::errc::management::collection_exists);
-    }
-
-    {
-        couchbase::core::operations::management::collection_drop_request req{ integration.ctx.bucket, scope_name, collection_name };
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_SUCCESS(resp.ctx.ec);
-    }
-
-    {
-        auto dropped = test::utils::wait_until(
-          [&]() { return !get_collection(integration.cluster, integration.ctx.bucket, scope_name, collection_name).has_value(); });
-        REQUIRE(dropped);
-    }
-
-    {
-        couchbase::core::operations::management::collection_drop_request req{ integration.ctx.bucket, scope_name, collection_name };
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::errc::common::collection_not_found);
+        REQUIRE(collection.history.value());
     }
-
     {
-        couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+        couchbase::core::operations::management::collection_update_request req{ integration.ctx.bucket, scope_name, collection_name };
+        req.history = false;
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_SUCCESS(resp.ctx.ec);
     }
-
-    {
-        auto dropped = test::utils::wait_until([&]() { return !scope_exists(integration.cluster, integration.ctx.bucket, scope_name); });
-        REQUIRE(dropped);
-    }
-
     {
-        couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
-        auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::errc::common::scope_not_found);
+        couchbase::core::topology::collections_manifest::collection collection;
+        auto no_history = test::utils::wait_until([&]() {
+            auto coll = get_collection(integration.cluster, integration.ctx.bucket, scope_name, collection_name);
+            if (coll.has_value()) {
+                if (!coll.value().history.value()) {
+                    return true;
+                }
+                return false;
+            }
+            return false;
+        });
+        REQUIRE(no_history);
     }
 }
 
@@ -1036,6 +1718,12 @@ 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]")
@@ -1499,7 +2187,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);
@@ -1524,7 +2213,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);
@@ -1554,7 +2243,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);
@@ -1628,7 +2318,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);
@@ -1781,7 +2472,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);
@@ -1954,18 +2646,20 @@ 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]")
@@ -2597,6 +3291,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);
+            }
         }
     }
 }
@@ -2662,7 +3362,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);