couchbase 4.1.2 → 4.1.3

package/deps/couchbase-cxx-client/test/test_integration_diagnostics.cxx

@@ -17,91 +17,91 @@
 
 #include "test_helper_integration.hxx"
 
-#include <couchbase/diagnostics.hxx>
-#include <couchbase/diagnostics_json.hxx>
+#include "core/diagnostics.hxx"
+#include "core/diagnostics_json.hxx"
 
 using namespace std::literals::chrono_literals;
 
 TEST_CASE("unit: serializing diagnostics report", "[unit]")
 {
-    couchbase::diag::diagnostics_result res{
+    couchbase::core::diag::diagnostics_result res{
         "0xdeadbeef",
         "cxx/1.0.0",
         {
           {
             {
-              couchbase::service_type::search,
+              couchbase::core::service_type::search,
               {
                 {
-                  couchbase::service_type::search,
+                  couchbase::core::service_type::search,
                   "0x1415F11",
                   1182000us,
                   "centos7-lx1.home.ingenthron.org:8094",
                   "127.0.0.1:54669",
-                  couchbase::diag::endpoint_state::connecting,
+                  couchbase::core::diag::endpoint_state::connecting,
                   std::nullopt,
                   "RECONNECTING, backoff for 4096ms from Fri Sep  1 00:03:44 PDT 2017",
                 },
               },
             },
             {
-              couchbase::service_type::key_value,
+              couchbase::core::service_type::key_value,
               {
                 {
-                  couchbase::service_type::key_value,
+                  couchbase::core::service_type::key_value,
                   "0x1415F12",
                   1182000us,
                   "centos7-lx1.home.ingenthron.org:11210",
                   "127.0.0.1:54670",
-                  couchbase::diag::endpoint_state::connected,
+                  couchbase::core::diag::endpoint_state::connected,
                   "bucketname",
                 },
               },
             },
             {
-              couchbase::service_type::query,
+              couchbase::core::service_type::query,
               {
                 {
-                  couchbase::service_type::query,
+                  couchbase::core::service_type::query,
                   "0x1415F13",
                   1182000us,
                   "centos7-lx1.home.ingenthron.org:8093",
                   "127.0.0.1:54671",
-                  couchbase::diag::endpoint_state::connected,
+                  couchbase::core::diag::endpoint_state::connected,
                 },
                 {
-                  couchbase::service_type::query,
+                  couchbase::core::service_type::query,
                   "0x1415F14",
                   1182000us,
                   "centos7-lx2.home.ingenthron.org:8095",
                   "127.0.0.1:54682",
-                  couchbase::diag::endpoint_state::disconnected,
+                  couchbase::core::diag::endpoint_state::disconnected,
                 },
               },
             },
             {
-              couchbase::service_type::analytics,
+              couchbase::core::service_type::analytics,
               {
                 {
-                  couchbase::service_type::analytics,
+                  couchbase::core::service_type::analytics,
                   "0x1415F15",
                   1182000us,
                   "centos7-lx1.home.ingenthron.org:8095",
                   "127.0.0.1:54675",
-                  couchbase::diag::endpoint_state::connected,
+                  couchbase::core::diag::endpoint_state::connected,
                 },
               },
             },
             {
-              couchbase::service_type::view,
+              couchbase::core::service_type::view,
               {
                 {
-                  couchbase::service_type::view,
+                  couchbase::core::service_type::view,
                   "0x1415F16",
                   1182000us,
                   "centos7-lx1.home.ingenthron.org:8092",
                   "127.0.0.1:54672",
-                  couchbase::diag::endpoint_state::connected,
+                  couchbase::core::diag::endpoint_state::connected,
                 },
               },
             },
@@ -109,7 +109,7 @@ TEST_CASE("unit: serializing diagnostics report", "[unit]")
         },
     };
 
-    auto expected = couchbase::utils::json::parse(R"(
+    auto expected = couchbase::core::utils::json::parse(R"(
 {
   "version": 2,
   "id": "0xdeadbeef",
@@ -180,76 +180,76 @@ TEST_CASE("integration: serializing ping report", "[integration]")
 {
     test::utils::integration_test_guard integration;
 
-    couchbase::diag::ping_result res{
+    couchbase::core::diag::ping_result res{
         "0xdeadbeef",
         "cxx/1.0.0",
         {
           {
             {
-              couchbase::service_type::search,
+              couchbase::core::service_type::search,
               {
                 {
-                  couchbase::service_type::search,
+                  couchbase::core::service_type::search,
                   "0x1415F11",
                   877909us,
                   "centos7-lx1.home.ingenthron.org:8094",
                   "127.0.0.1:54669",
-                  couchbase::diag::ping_state::ok,
+                  couchbase::core::diag::ping_state::ok,
                 },
               },
             },
             {
-              couchbase::service_type::key_value,
+              couchbase::core::service_type::key_value,
               {
                 {
-                  couchbase::service_type::key_value,
+                  couchbase::core::service_type::key_value,
                   "0x1415F12",
                   1182000us,
                   "centos7-lx1.home.ingenthron.org:11210",
                   "127.0.0.1:54670",
-                  couchbase::diag::ping_state::ok,
+                  couchbase::core::diag::ping_state::ok,
                   "bucketname",
                 },
               },
             },
             {
-              couchbase::service_type::query,
+              couchbase::core::service_type::query,
               {
                 {
-                  couchbase::service_type::query,
+                  couchbase::core::service_type::query,
                   "0x1415F14",
                   2213us,
                   "centos7-lx2.home.ingenthron.org:8095",
                   "127.0.0.1:54682",
-                  couchbase::diag::ping_state::timeout,
+                  couchbase::core::diag::ping_state::timeout,
                 },
               },
             },
             {
-              couchbase::service_type::analytics,
+              couchbase::core::service_type::analytics,
               {
                 {
-                  couchbase::service_type::analytics,
+                  couchbase::core::service_type::analytics,
                   "0x1415F15",
                   2213us,
                   "centos7-lx1.home.ingenthron.org:8095",
                   "127.0.0.1:54675",
-                  couchbase::diag::ping_state::error,
+                  couchbase::core::diag::ping_state::error,
                   std::nullopt,
                   "endpoint returned HTTP code 500!",
                 },
               },
             },
             {
-              couchbase::service_type::view,
+              couchbase::core::service_type::view,
               {
                 {
-                  couchbase::service_type::view,
+                  couchbase::core::service_type::view,
                   "0x1415F16",
                   45585us,
                   "centos7-lx1.home.ingenthron.org:8092",
                   "127.0.0.1:54672",
-                  couchbase::diag::ping_state::ok,
+                  couchbase::core::diag::ping_state::ok,
                 },
               },
             },
@@ -257,7 +257,7 @@ TEST_CASE("integration: serializing ping report", "[integration]")
         },
     };
 
-    auto expected = couchbase::utils::json::parse(R"(
+    auto expected = couchbase::core::utils::json::parse(R"(
 {
   "version": 2,
   "id": "0xdeadbeef",
@@ -323,26 +323,25 @@ TEST_CASE("integration: fetch diagnostics after N1QL query", "[integration]")
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     {
-        couchbase::operations::query_request req{ "SELECT 'hello, couchbase' AS greetings" };
+        couchbase::core::operations::query_request req{ "SELECT 'hello, couchbase' AS greetings" };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec);
         INFO("rows.size() =" << resp.rows.size())
         REQUIRE(resp.rows.size() == 1);
         INFO("row=" << resp.rows[0])
         REQUIRE(resp.rows[0] == R"({"greetings":"hello, couchbase"})");
     }
     {
-        auto barrier = std::make_shared<std::promise<couchbase::diag::diagnostics_result>>();
+        auto barrier = std::make_shared<std::promise<couchbase::core::diag::diagnostics_result>>();
         auto f = barrier->get_future();
         integration.cluster->diagnostics(
-          "my_report_id", [barrier](couchbase::diag::diagnostics_result&& resp) mutable { barrier->set_value(std::move(resp)); });
+          "my_report_id", [barrier](couchbase::core::diag::diagnostics_result&& resp) mutable { barrier->set_value(std::move(resp)); });
         auto res = f.get();
         REQUIRE(res.id == "my_report_id");
         REQUIRE(res.sdk.find("cxx/") == 0);
-        REQUIRE(res.services[couchbase::service_type::key_value].size() > 1);
-        REQUIRE(res.services[couchbase::service_type::query].size() == 1);
-        REQUIRE(res.services[couchbase::service_type::query][0].state == couchbase::diag::endpoint_state::connected);
+        REQUIRE(res.services[couchbase::core::service_type::key_value].size() > 1);
+        REQUIRE(res.services[couchbase::core::service_type::query].size() == 1);
+        REQUIRE(res.services[couchbase::core::service_type::query][0].state == couchbase::core::diag::endpoint_state::connected);
     }
 }
 
@@ -353,36 +352,36 @@ TEST_CASE("integration: ping", "[integration]")
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     {
-        auto barrier = std::make_shared<std::promise<couchbase::diag::ping_result>>();
+        auto barrier = std::make_shared<std::promise<couchbase::core::diag::ping_result>>();
         auto f = barrier->get_future();
         integration.cluster->ping(
-          "my_report_id", {}, {}, [barrier](couchbase::diag::ping_result&& resp) mutable { barrier->set_value(std::move(resp)); });
+          "my_report_id", {}, {}, [barrier](couchbase::core::diag::ping_result&& resp) mutable { barrier->set_value(std::move(resp)); });
         auto res = f.get();
         REQUIRE(res.services.size() > 0);
 
-        REQUIRE(res.services.count(couchbase::service_type::key_value) > 0);
-        REQUIRE(res.services[couchbase::service_type::key_value].size() > 0);
+        REQUIRE(res.services.count(couchbase::core::service_type::key_value) > 0);
+        REQUIRE(res.services[couchbase::core::service_type::key_value].size() > 0);
 
-        REQUIRE(res.services.count(couchbase::service_type::management) > 0);
-        REQUIRE(res.services[couchbase::service_type::management].size() > 0);
+        REQUIRE(res.services.count(couchbase::core::service_type::management) > 0);
+        REQUIRE(res.services[couchbase::core::service_type::management].size() > 0);
 
-        REQUIRE(res.services.count(couchbase::service_type::view) > 0);
-        REQUIRE(res.services[couchbase::service_type::view].size() > 0);
+        REQUIRE(res.services.count(couchbase::core::service_type::view) > 0);
+        REQUIRE(res.services[couchbase::core::service_type::view].size() > 0);
 
-        REQUIRE(res.services.count(couchbase::service_type::query) > 0);
-        REQUIRE(res.services[couchbase::service_type::query].size() > 0);
+        REQUIRE(res.services.count(couchbase::core::service_type::query) > 0);
+        REQUIRE(res.services[couchbase::core::service_type::query].size() > 0);
 
-        REQUIRE(res.services.count(couchbase::service_type::search) > 0);
-        REQUIRE(res.services[couchbase::service_type::search].size() > 0);
+        REQUIRE(res.services.count(couchbase::core::service_type::search) > 0);
+        REQUIRE(res.services[couchbase::core::service_type::search].size() > 0);
 
         if (integration.ctx.version.supports_analytics()) {
-            REQUIRE(res.services.count(couchbase::service_type::analytics) > 0);
-            REQUIRE(res.services[couchbase::service_type::analytics].size() > 0);
+            REQUIRE(res.services.count(couchbase::core::service_type::analytics) > 0);
+            REQUIRE(res.services[couchbase::core::service_type::analytics].size() > 0);
         }
 
         if (integration.ctx.version.supports_eventing_functions()) {
-            REQUIRE(res.services.count(couchbase::service_type::eventing) > 0);
-            REQUIRE(res.services[couchbase::service_type::eventing].size() > 0);
+            REQUIRE(res.services.count(couchbase::core::service_type::eventing) > 0);
+            REQUIRE(res.services[couchbase::core::service_type::eventing].size() > 0);
         }
 
         REQUIRE(res.id == "my_report_id");
@@ -398,20 +397,20 @@ TEST_CASE("integration: ping allows to select services", "[integration]")
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     {
-        auto barrier = std::make_shared<std::promise<couchbase::diag::ping_result>>();
+        auto barrier = std::make_shared<std::promise<couchbase::core::diag::ping_result>>();
         auto f = barrier->get_future();
         integration.cluster->ping({},
                                   {},
-                                  { couchbase::service_type::key_value, couchbase::service_type::query },
-                                  [barrier](couchbase::diag::ping_result&& resp) mutable { barrier->set_value(std::move(resp)); });
+                                  { couchbase::core::service_type::key_value, couchbase::core::service_type::query },
+                                  [barrier](couchbase::core::diag::ping_result&& resp) mutable { barrier->set_value(std::move(resp)); });
         auto res = f.get();
         REQUIRE(res.services.size() == 2);
 
-        REQUIRE(res.services.count(couchbase::service_type::key_value) > 0);
-        REQUIRE(res.services[couchbase::service_type::key_value].size() > 0);
+        REQUIRE(res.services.count(couchbase::core::service_type::key_value) > 0);
+        REQUIRE(res.services[couchbase::core::service_type::key_value].size() > 0);
 
-        REQUIRE(res.services.count(couchbase::service_type::query) > 0);
-        REQUIRE(res.services[couchbase::service_type::query].size() > 0);
+        REQUIRE(res.services.count(couchbase::core::service_type::query) > 0);
+        REQUIRE(res.services[couchbase::core::service_type::query].size() > 0);
     }
 }
 
@@ -420,18 +419,18 @@ TEST_CASE("integration: ping allows to select bucket and opens it automatically"
     test::utils::integration_test_guard integration;
 
     {
-        auto barrier = std::make_shared<std::promise<couchbase::diag::ping_result>>();
+        auto barrier = std::make_shared<std::promise<couchbase::core::diag::ping_result>>();
         auto f = barrier->get_future();
         integration.cluster->ping({},
                                   integration.ctx.bucket,
-                                  { couchbase::service_type::key_value },
-                                  [barrier](couchbase::diag::ping_result&& resp) mutable { barrier->set_value(std::move(resp)); });
+                                  { couchbase::core::service_type::key_value },
+                                  [barrier](couchbase::core::diag::ping_result&& resp) mutable { barrier->set_value(std::move(resp)); });
         auto res = f.get();
         REQUIRE(res.services.size() == 1);
 
-        REQUIRE(res.services.count(couchbase::service_type::key_value) > 0);
-        REQUIRE(res.services[couchbase::service_type::key_value].size() > 0);
-        REQUIRE(res.services[couchbase::service_type::key_value][0].bucket.has_value());
-        REQUIRE(res.services[couchbase::service_type::key_value][0].bucket.value() == integration.ctx.bucket);
+        REQUIRE(res.services.count(couchbase::core::service_type::key_value) > 0);
+        REQUIRE(res.services[couchbase::core::service_type::key_value].size() > 0);
+        REQUIRE(res.services[couchbase::core::service_type::key_value][0].bucket.has_value());
+        REQUIRE(res.services[couchbase::core::service_type::key_value][0].bucket.value() == integration.ctx.bucket);
     }
 }

package/deps/couchbase-cxx-client/test/test_integration_durability.cxx

@@ -17,6 +17,10 @@
 
 #include "test_helper_integration.hxx"
 
+#include "profile.hxx"
+
+#include <couchbase/cluster.hxx>
+
 TEST_CASE("integration: durable operations", "[integration]")
 {
     test::utils::integration_test_guard integration;
@@ -26,57 +30,198 @@ TEST_CASE("integration: durable operations", "[integration]")
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
+    {
+        const tao::json::value value = {
+            { "a", 1.0 },
+            { "b", 2.0 },
+        };
+        couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::json::generate_binary(value) };
+        req.durability_level = couchbase::durability_level::majority_and_persist_to_active;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(!resp.cas.empty());
+        REQUIRE(resp.token.sequence_number() != 0);
+    }
+    {
+        const tao::json::value value = {
+            { "foo", "bar" },
+        };
+        couchbase::core::operations::replace_request req{ id, couchbase::core::utils::json::generate_binary(value) };
+        req.durability_level = couchbase::durability_level::majority_and_persist_to_active;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(!resp.cas.empty());
+        REQUIRE(resp.token.sequence_number() != 0);
+    }
+    {
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert("baz", 42) }.specs();
+        req.durability_level = couchbase::durability_level::majority_and_persist_to_active;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(!resp.cas.empty());
+        REQUIRE(resp.token.sequence_number() != 0);
+    }
+    {
+        couchbase::core::operations::get_request req{ id };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(!resp.cas.empty());
+        REQUIRE(resp.value == couchbase::core::utils::to_binary(R"({"foo":"bar","baz":42})"));
+    }
+    {
+        couchbase::core::operations::remove_request req{ id };
+        req.durability_level = couchbase::durability_level::majority_and_persist_to_active;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec());
+        REQUIRE(!resp.cas.empty());
+        REQUIRE(resp.token.sequence_number() != 0);
+    }
+}
+
+TEST_CASE("integration: legacy durability persist to active and replicate to one", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+    if (integration.number_of_replicas() == 0 || integration.number_of_nodes() <= integration.number_of_replicas()) {
+        return;
+    }
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    std::string key = test::utils::uniq_id("upsert_legacy");
+
+    auto collection = couchbase::cluster(integration.cluster)
+                        .bucket(integration.ctx.bucket)
+                        .scope(couchbase::scope::default_name)
+                        .collection(couchbase::collection::default_name);
+
+    couchbase::cas cas{};
+
+    {
+        profile fry{ "fry", "Philip J. Fry", 1974 };
+        auto options = couchbase::upsert_options{}.durability(couchbase::persist_to::active, couchbase::replicate_to::one);
+        auto [ctx, result] = collection.upsert(key, fry, options).get();
+        REQUIRE_SUCCESS(ctx.ec());
+        REQUIRE_FALSE(result.cas().empty());
+        REQUIRE(result.mutation_token().has_value());
+        cas = result.cas();
+    }
+
+    {
+        auto [ctx, result] = collection.get(key, {}).get();
+        REQUIRE_SUCCESS(ctx.ec());
+        REQUIRE(result.cas() == cas);
+        auto fry = result.content_as<profile>();
+        REQUIRE(fry.username == "fry");
+    }
+}
+
+TEST_CASE("integration: low level legacy durability impossible if number of nodes too high", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    if (integration.number_of_replicas() == 3) {
+        return;
+    }
+
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
+    const tao::json::value value = {
+        { "a", 1.0 },
+        { "b", 2.0 },
+    };
+    {
+        couchbase::core::operations::upsert_request_with_legacy_durability req{
+            { id, couchbase::core::utils::json::generate_binary(value) },
+            couchbase::persist_to::four,
+            couchbase::replicate_to::one,
+        };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::durability_impossible);
+    }
+    {
+        couchbase::core::operations::upsert_request_with_legacy_durability req{
+            { id, couchbase::core::utils::json::generate_binary(value) },
+            couchbase::persist_to::active,
+            couchbase::replicate_to::three,
+        };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::durability_impossible);
+    }
+}
+
+TEST_CASE("integration: low level legacy durability persist to active and replicate to one", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    if (integration.number_of_replicas() < 1) {
+        return;
+    }
+
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
     {
         const tao::json::value value = {
             { "a", 1.0 },
             { "b", 2.0 },
         };
-        couchbase::operations::upsert_request req{ id, couchbase::utils::json::generate_binary(value) };
-        req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+        couchbase::core::operations::upsert_request_with_legacy_durability req{
+            { id, couchbase::core::utils::json::generate_binary(value) },
+            couchbase::persist_to::active,
+            couchbase::replicate_to::one,
+        };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        REQUIRE(resp.token.sequence_number != 0);
+        REQUIRE(resp.token.sequence_number() != 0);
     }
+
     {
         const tao::json::value value = {
             { "foo", "bar" },
         };
-        couchbase::operations::replace_request req{ id, couchbase::utils::json::generate_binary(value) };
-        req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+        couchbase::core::operations::replace_request_with_legacy_durability req{
+            { id, couchbase::core::utils::json::generate_binary(value) },
+            couchbase::persist_to::active,
+            couchbase::replicate_to::one,
+        };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        REQUIRE(resp.token.sequence_number != 0);
+        REQUIRE(resp.token.sequence_number() != 0);
     }
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_upsert, false, false, false, "baz", "42");
-        req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+        couchbase::core::operations::mutate_in_request_with_legacy_durability req{
+            { id },
+            couchbase::persist_to::active,
+            couchbase::replicate_to::one,
+        };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert("baz", 42) }.specs();
+
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        REQUIRE(resp.token.sequence_number != 0);
+        REQUIRE(resp.token.sequence_number() != 0);
     }
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        REQUIRE(resp.value == couchbase::utils::to_binary(R"({"foo":"bar","baz":42})"));
+        REQUIRE(resp.value == couchbase::core::utils::to_binary(R"({"foo":"bar","baz":42})"));
     }
     {
-        couchbase::operations::remove_request req{ id };
-        req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
+        couchbase::core::operations::remove_request_with_legacy_durability req{
+            { id },
+            couchbase::persist_to::active,
+            couchbase::replicate_to::one,
+        };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_SUCCESS(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        REQUIRE(resp.token.sequence_number != 0);
+        REQUIRE(resp.token.sequence_number() != 0);
     }
 }