couchbase 4.1.1 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/test_integration_crud.cxx

@@ -19,33 +19,35 @@
 
 #include "utils/move_only_context.hxx"
 
+#include <couchbase/lookup_in_specs.hxx>
+#include <couchbase/mutate_in_specs.hxx>
+
 static const tao::json::value basic_doc = {
     { "a", 1.0 },
     { "b", 2.0 },
 };
-static const std::string basic_doc_json = couchbase::utils::json::generate(basic_doc);
+static const std::vector<std::byte> basic_doc_json = couchbase::core::utils::json::generate_binary(basic_doc);
 
 TEST_CASE("integration: crud on default collection", "[integration]")
 {
     test::utils::integration_test_guard 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") };
 
     // create
     {
-        couchbase::operations::insert_request req{ id, basic_doc_json };
+        couchbase::core::operations::insert_request req{ id, basic_doc_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        INFO(resp.ctx.ec().message())
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE(!resp.cas.empty());
-        INFO("seqno=" << resp.token.sequence_number)
-        REQUIRE(resp.token.sequence_number != 0);
+        REQUIRE(resp.token.sequence_number() != 0);
     }
 
     // read
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.value == basic_doc_json);
     }
@@ -53,29 +55,29 @@ TEST_CASE("integration: crud on default collection", "[integration]")
     // update
     {
         auto doc = basic_doc;
-        auto json = couchbase::utils::json::generate(doc);
+        auto json = couchbase::core::utils::json::generate_binary(doc);
         doc["a"] = 2.0;
 
         {
-            couchbase::operations::replace_request req{ id, json };
+            couchbase::core::operations::replace_request req{ id, json };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
         }
 
         {
-            couchbase::operations::get_request req{ id };
+            couchbase::core::operations::get_request req{ id };
             auto resp = test::utils::execute(integration.cluster, req);
             REQUIRE(resp.value == json);
         }
 
         {
-            couchbase::operations::upsert_request req{ id, basic_doc_json };
+            couchbase::core::operations::upsert_request req{ id, basic_doc_json };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
         }
 
         {
-            couchbase::operations::get_request req{ id };
+            couchbase::core::operations::get_request req{ id };
             auto resp = test::utils::execute(integration.cluster, req);
             REQUIRE(resp.value == basic_doc_json);
         }
@@ -84,15 +86,15 @@ TEST_CASE("integration: crud on default collection", "[integration]")
     // delete
     {
         {
-            couchbase::operations::remove_request req{ id };
+            couchbase::core::operations::remove_request req{ id };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
         }
 
         {
-            couchbase::operations::get_request req{ id };
+            couchbase::core::operations::get_request req{ id };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+            REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
         }
     }
 }
@@ -102,29 +104,29 @@ TEST_CASE("integration: get", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("get") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("get") };
 
     SECTION("miss")
     {
-        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(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+        INFO(resp.ctx.ec().message());
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
     }
 
     SECTION("hit")
     {
         auto flags = 0xdeadbeef;
         {
-            couchbase::operations::insert_request req{ id, basic_doc_json };
+            couchbase::core::operations::insert_request req{ id, basic_doc_json };
             req.flags = flags;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
         }
         {
-            couchbase::operations::get_request req{ id };
+            couchbase::core::operations::get_request req{ id };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
             REQUIRE(resp.value == basic_doc_json);
             REQUIRE(resp.flags == flags);
         }
@@ -136,28 +138,28 @@ TEST_CASE("integration: touch", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("touch") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("touch") };
 
     SECTION("miss")
     {
-        couchbase::operations::touch_request req{ id };
+        couchbase::core::operations::touch_request req{ id };
         req.expiry = 666;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
     }
 
     SECTION("hit")
     {
         {
-            couchbase::operations::insert_request req{ id, basic_doc_json };
+            couchbase::core::operations::insert_request req{ id, basic_doc_json };
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
         }
         {
-            couchbase::operations::touch_request req{ id };
+            couchbase::core::operations::touch_request req{ id };
             req.expiry = 666;
             auto resp = test::utils::execute(integration.cluster, req);
-            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE_FALSE(resp.ctx.ec());
         }
     }
 }
@@ -167,83 +169,83 @@ TEST_CASE("integration: pessimistic locking", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("locking") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("locking") };
     uint32_t lock_time = 10;
 
-    couchbase::cas cas;
+    couchbase::cas cas{};
 
     {
-        couchbase::operations::insert_request req{ id, basic_doc_json };
+        couchbase::core::operations::insert_request req{ id, basic_doc_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
         cas = resp.cas;
     }
 
     // lock and record CAS of the locked document
     {
-        couchbase::operations::get_and_lock_request req{ id };
+        couchbase::core::operations::get_and_lock_request req{ id };
         req.lock_time = lock_time;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE(cas != resp.cas);
         cas = resp.cas;
     }
 
     // real CAS is masked now and not visible by regular GET
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE(cas != resp.cas);
     }
 
     // it is not allowed to lock the same key twice
     {
-        couchbase::operations::get_and_lock_request req{ id };
+        couchbase::core::operations::get_and_lock_request req{ id };
         req.lock_time = lock_time;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::ambiguous_timeout);
-        REQUIRE(resp.ctx.retry_reasons.count(couchbase::io::retry_reason::kv_locked) == 1);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::common::ambiguous_timeout);
+        REQUIRE(resp.ctx.retried_because_of(couchbase::retry_reason::kv_locked));
     }
 
     // but unlock operation is not retried in this case, because it would never have succeeded
     {
-        couchbase::operations::unlock_request req{ id };
-        req.cas = couchbase::cas{ cas.value - 1 };
+        couchbase::core::operations::unlock_request req{ id };
+        req.cas = couchbase::cas{ cas.value() - 1 };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_locked);
-        REQUIRE(resp.ctx.retry_reasons.count(couchbase::io::retry_reason::kv_locked) == 0);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_locked);
+        REQUIRE_FALSE(resp.ctx.retried_because_of(couchbase::retry_reason::kv_locked));
     }
 
     // but mutating the locked key is allowed with known cas
     {
-        couchbase::operations::replace_request req{ id, basic_doc_json };
+        couchbase::core::operations::replace_request req{ id, basic_doc_json };
         req.cas = cas;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::get_and_lock_request req{ id };
+        couchbase::core::operations::get_and_lock_request req{ id };
         req.lock_time = lock_time;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
         cas = resp.cas;
     }
 
     // to unlock key without mutation, unlock might be used
     {
-        couchbase::operations::unlock_request req{ id };
+        couchbase::core::operations::unlock_request req{ id };
         req.cas = cas;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     // now the key is not locked
     {
-        couchbase::operations::upsert_request req{ id, basic_doc_json };
+        couchbase::core::operations::upsert_request req{ id, basic_doc_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 }
 
@@ -252,28 +254,28 @@ TEST_CASE("integration: lock/unlock without lock time", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("locking") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("locking") };
 
     {
-        couchbase::operations::insert_request req{ id, basic_doc_json };
+        couchbase::core::operations::insert_request req{ id, basic_doc_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
-    couchbase::cas cas;
+    couchbase::cas cas{};
 
     {
-        couchbase::operations::get_and_lock_request req{ id };
+        couchbase::core::operations::get_and_lock_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
         cas = resp.cas;
     }
 
     {
-        couchbase::operations::unlock_request req{ id };
+        couchbase::core::operations::unlock_request req{ id };
         req.cas = cas;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 }
 
@@ -282,28 +284,28 @@ TEST_CASE("integration: touch with zero expiry resets expiry", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("get_reset_expiry_key") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("get_reset_expiry_key") };
 
     {
-        couchbase::operations::insert_request req{ id, basic_doc_json };
+        couchbase::core::operations::insert_request req{ id, basic_doc_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     // set expiry with touch
     {
-        couchbase::operations::touch_request req{ id };
+        couchbase::core::operations::touch_request req{ id };
         req.expiry = 1;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     // reset expiry
     {
-        couchbase::operations::get_and_touch_request req{ id };
+        couchbase::core::operations::get_and_touch_request req{ id };
         req.expiry = 0;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     // wait for original expiry to pass
@@ -311,9 +313,9 @@ TEST_CASE("integration: touch with zero expiry resets expiry", "[integration]")
 
     // check that the key still exists
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE(resp.value == basic_doc_json);
     }
 }
@@ -323,31 +325,31 @@ TEST_CASE("integration: exists", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("exists") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("exists") };
 
     {
-        couchbase::operations::exists_request req{ id };
+        couchbase::core::operations::exists_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.exists());
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE_FALSE(resp.deleted);
         REQUIRE(resp.cas.empty());
         REQUIRE(resp.sequence_number == 0);
     }
 
     {
-        couchbase::operations::insert_request req{ id, basic_doc_json };
+        couchbase::core::operations::insert_request req{ id, basic_doc_json };
         req.expiry = 1878422400;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE_FALSE(resp.cas.empty());
     }
 
     {
-        couchbase::operations::exists_request req{ id };
+        couchbase::core::operations::exists_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.exists());
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE_FALSE(resp.deleted);
         REQUIRE_FALSE(resp.cas.empty());
         REQUIRE(resp.sequence_number != 0);
@@ -355,16 +357,16 @@ TEST_CASE("integration: exists", "[integration]")
     }
 
     {
-        couchbase::operations::remove_request req{ id };
+        couchbase::core::operations::remove_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::exists_request req{ id };
+        couchbase::core::operations::exists_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.exists());
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
         REQUIRE(resp.deleted);
         REQUIRE_FALSE(resp.cas.empty());
         REQUIRE(resp.sequence_number != 0);
@@ -377,19 +379,19 @@ TEST_CASE("integration: zero length value", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("zero_length_value") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("zero_length_value") };
 
     {
-        couchbase::operations::insert_request req{ id, "" };
+        couchbase::core::operations::insert_request req{ id, couchbase::core::utils::to_binary("") };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == "");
+        REQUIRE_FALSE(resp.ctx.ec());
+        REQUIRE(resp.value == couchbase::core::utils::to_binary(""));
     }
 }
 
@@ -398,27 +400,27 @@ TEST_CASE("integration: ops on missing document", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", "missing_key" };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", "missing_key" };
 
     SECTION("get")
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
     }
 
     SECTION("remove")
     {
-        couchbase::operations::remove_request req{ id };
+        couchbase::core::operations::remove_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
     }
 
     SECTION("replace")
     {
-        couchbase::operations::replace_request req{ id, "" };
+        couchbase::core::operations::replace_request req{ id, couchbase::core::utils::to_binary("") };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_not_found);
     }
 }
 
@@ -427,30 +429,30 @@ TEST_CASE("integration: cas replace", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("cas_replace") };
-    couchbase::cas cas;
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("cas_replace") };
+    couchbase::cas cas{};
 
     {
-        couchbase::operations::insert_request req{ id, basic_doc_json };
+        couchbase::core::operations::insert_request req{ id, basic_doc_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
         cas = resp.cas;
     }
 
     SECTION("incorrect")
     {
-        couchbase::operations::replace_request req{ id, "" };
-        req.cas = couchbase::cas{ cas.value + 1 };
+        couchbase::core::operations::replace_request req{ id, couchbase::core::utils::to_binary("") };
+        req.cas = couchbase::cas{ cas.value() + 1 };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::cas_mismatch);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::common::cas_mismatch);
     }
 
     SECTION("correct")
     {
-        couchbase::operations::replace_request req{ id, "" };
+        couchbase::core::operations::replace_request req{ id, couchbase::core::utils::to_binary("") };
         req.cas = cas;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 }
 
@@ -464,49 +466,60 @@ TEST_CASE("integration: upsert preserve expiry", "[integration]")
 
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("preserve_expiry") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("preserve_expiry") };
     uint32_t expiry = std::numeric_limits<uint32_t>::max();
-    auto expiry_path = "$document.exptime";
 
     {
-        couchbase::operations::upsert_request req{ id, basic_doc_json };
+        couchbase::core::operations::upsert_request req{ id, basic_doc_json };
         req.expiry = expiry;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::lookup_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, true, expiry_path);
+        couchbase::core::operations::lookup_in_request req{ id };
+        req.specs =
+          couchbase::lookup_in_specs{
+              couchbase::lookup_in_specs::get(couchbase::subdoc::lookup_in_macro::expiry_time).xattr(),
+          }
+            .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(expiry == std::stoul(resp.fields[0].value));
+        REQUIRE(expiry == std::stoul(test::utils::to_string(resp.fields[0].value)));
     }
 
     {
-        couchbase::operations::upsert_request req{ id, basic_doc_json };
+        couchbase::core::operations::upsert_request req{ id, basic_doc_json };
         req.preserve_expiry = true;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::lookup_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, true, expiry_path);
+        couchbase::core::operations::lookup_in_request req{ id };
+        req.specs =
+          couchbase::lookup_in_specs{
+              couchbase::lookup_in_specs::get(couchbase::subdoc::lookup_in_macro::expiry_time).xattr(),
+          }
+            .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(expiry == std::stoul(resp.fields[0].value));
+        REQUIRE(expiry == std::stoul(test::utils::to_string(resp.fields[0].value)));
     }
 
     {
-        couchbase::operations::upsert_request req{ id, basic_doc_json };
+        couchbase::core::operations::upsert_request req{ id, basic_doc_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     {
-        couchbase::operations::lookup_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, true, expiry_path);
+        couchbase::core::operations::lookup_in_request req{ id };
+        req.specs =
+          couchbase::lookup_in_specs{
+              couchbase::lookup_in_specs::get(couchbase::subdoc::lookup_in_macro::expiry_time).xattr(),
+          }
+            .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(0 == std::stoul(resp.fields[0].value));
+        REQUIRE(0 == std::stoul(test::utils::to_string(resp.fields[0].value)));
     }
 }
 
@@ -517,19 +530,19 @@ TEST_CASE("integration: upsert with handler capturing non-copyable object", "[in
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
     {
-        couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
-        couchbase::operations::upsert_request req{ id, R"({"foo":"bar"})" };
-        auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
+        couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
+        couchbase::core::operations::upsert_request req{ id, couchbase::core::utils::to_binary(R"({"foo":"bar"})") };
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::upsert_response>>();
         auto f = barrier->get_future();
         test::utils::move_only_context ctx("foobar");
-        auto handler = [barrier, ctx = std::move(ctx)](couchbase::operations::upsert_response&& resp) {
+        auto handler = [barrier, ctx = std::move(ctx)](couchbase::core::operations::upsert_response&& resp) {
             CHECK(ctx.payload() == "foobar");
             barrier->set_value(std::move(resp));
         };
         integration.cluster->execute(req, std::move(handler));
         auto resp = f.get();
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        INFO(resp.ctx.ec().message())
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 }
 
@@ -538,9 +551,9 @@ TEST_CASE("integration: upsert may trigger snappy compression", "[integration]")
     test::utils::integration_test_guard 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") };
 
-    std::string compressible_json = R"(
+    auto compressible_json = couchbase::core::utils::to_binary(R"(
 {
   "name": "Emmy-lou Dickerson",
   "age": 26,
@@ -569,19 +582,19 @@ TEST_CASE("integration: upsert may trigger snappy compression", "[integration]")
     ]
   }
 }
-)";
+)");
 
     // create
     {
-        couchbase::operations::insert_request req{ id, compressible_json };
+        couchbase::core::operations::insert_request req{ id, compressible_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        INFO(resp.ctx.ec.message())
-        REQUIRE_FALSE(resp.ctx.ec);
+        INFO(resp.ctx.ec().message())
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     // read
     {
-        couchbase::operations::get_request req{ id };
+        couchbase::core::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.value == compressible_json);
     }
@@ -604,12 +617,12 @@ TEST_CASE("integration: multi-threaded open/close bucket", "[integration]")
 
     for (auto i = 0; i < number_of_threads; ++i) {
         threads.emplace_back([&integration]() {
-            couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
-            couchbase::operations::upsert_request req{ id, basic_doc_json };
+            couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
+            couchbase::core::operations::upsert_request req{ id, basic_doc_json };
             req.timeout = std::chrono::seconds{ 10 };
-            if (auto resp = test::utils::execute(integration.cluster, req); resp.ctx.ec) {
-                if (resp.ctx.ec != couchbase::error::common_errc::ambiguous_timeout) {
-                    throw std::system_error(resp.ctx.ec);
+            if (auto resp = test::utils::execute(integration.cluster, req); resp.ctx.ec()) {
+                if (resp.ctx.ec() != couchbase::errc::common::ambiguous_timeout) {
+                    throw std::system_error(resp.ctx.ec());
                 }
             }
         });
@@ -635,7 +648,7 @@ TEST_CASE("integration: open bucket that does not exist", "[integration]")
     auto f = barrier->get_future();
     integration.cluster->open_bucket(bucket_name, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
     auto rc = f.get();
-    REQUIRE(rc == couchbase::error::common_errc::bucket_not_found);
+    REQUIRE(rc == couchbase::errc::common::bucket_not_found);
 }
 
 TEST_CASE("integration: upsert returns valid mutation token", "[integration]")
@@ -643,63 +656,69 @@ TEST_CASE("integration: upsert returns valid mutation token", "[integration]")
     test::utils::integration_test_guard integration;
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
 
-    couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("upsert_mt") };
+    couchbase::core::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("upsert_mt") };
 
     couchbase::mutation_token token{};
     {
-        couchbase::operations::upsert_request req{ id, basic_doc_json };
+        couchbase::core::operations::upsert_request req{ id, basic_doc_json };
         auto resp = test::utils::execute(integration.cluster, req);
         token = resp.token;
-        REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(token.bucket_name == integration.ctx.bucket);
-        REQUIRE(token.partition_uuid > 0);
-        REQUIRE(token.sequence_number > 0);
+        REQUIRE_FALSE(resp.ctx.ec());
+        REQUIRE(token.bucket_name() == integration.ctx.bucket);
+        REQUIRE(token.partition_uuid() > 0);
+        REQUIRE(token.sequence_number() > 0);
     }
     {
-        couchbase::operations::lookup_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, true, "$document.vbucket_uuid");
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::get, true, "$document.seqno");
+        couchbase::core::operations::lookup_in_request req{ id };
+        req.specs =
+          couchbase::lookup_in_specs{
+              couchbase::lookup_in_specs::get(couchbase::subdoc::lookup_in_macro::vbucket_uuid).xattr(),
+              couchbase::lookup_in_specs::get(couchbase::subdoc::lookup_in_macro::sequence_number).xattr(),
+          }
+            .specs();
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.fields[0].value.find("\"0x") == 0);
-        REQUIRE(std::strtoull(resp.fields[0].value.data() + 3, nullptr, 16) == token.partition_uuid);
-        REQUIRE(resp.fields[1].value.find("\"0x") == 0);
-        REQUIRE(std::strtoull(resp.fields[1].value.data() + 3, nullptr, 16) == token.sequence_number);
+        REQUIRE_FALSE(resp.ctx.ec());
+        auto vbucket_uuid = test::utils::to_string(resp.fields[0].value);
+        REQUIRE(vbucket_uuid.find("\"0x") == 0);
+        REQUIRE(std::strtoull(vbucket_uuid.data() + 3, nullptr, 16) == token.partition_uuid());
+        auto sequence_number = test::utils::to_string(resp.fields[1].value);
+        REQUIRE(sequence_number.find("\"0x") == 0);
+        REQUIRE(std::strtoull(sequence_number.data() + 3, nullptr, 16) == token.sequence_number());
     }
     {
-        couchbase::operations::insert_request req{ id, basic_doc_json };
+        couchbase::core::operations::insert_request req{ id, basic_doc_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_exists);
-        REQUIRE(resp.token.bucket_name.empty());
-        REQUIRE(resp.token.partition_id == 0);
-        REQUIRE(resp.token.partition_uuid == 0);
-        REQUIRE(resp.token.sequence_number == 0);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_exists);
+        REQUIRE(resp.token.bucket_name().empty());
+        REQUIRE(resp.token.partition_id() == 0);
+        REQUIRE(resp.token.partition_uuid() == 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, true, false, "foo", "42");
-        req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::insert;
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::upsert("foo", "42").create_path() }.specs();
+        req.store_semantics = couchbase::store_semantics::insert;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_exists);
-        REQUIRE(resp.token.bucket_name.empty());
-        REQUIRE(resp.token.partition_id == 0);
-        REQUIRE(resp.token.partition_uuid == 0);
-        REQUIRE(resp.token.sequence_number == 0);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::document_exists);
+        REQUIRE(resp.token.bucket_name().empty());
+        REQUIRE(resp.token.partition_id() == 0);
+        REQUIRE(resp.token.partition_uuid() == 0);
+        REQUIRE(resp.token.sequence_number() == 0);
     }
     {
-        couchbase::operations::mutate_in_request req{ id };
-        req.specs.add_spec(couchbase::protocol::subdoc_opcode::dict_add, false, false, false, "a", "{}");
-        req.store_semantics = couchbase::protocol::mutate_in_request_body::store_semantics_type::replace;
+        couchbase::core::operations::mutate_in_request req{ id };
+        req.specs = couchbase::mutate_in_specs{ couchbase::mutate_in_specs::insert("a", tao::json::empty_object) }.specs();
+        req.store_semantics = couchbase::store_semantics::replace;
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::path_exists);
-        REQUIRE(resp.token.bucket_name.empty());
-        REQUIRE(resp.token.partition_id == 0);
-        REQUIRE(resp.token.partition_uuid == 0);
-        REQUIRE(resp.token.sequence_number == 0);
-        REQUIRE(resp.first_error_index == 0);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::key_value::path_exists);
+        REQUIRE(resp.token.bucket_name().empty());
+        REQUIRE(resp.token.partition_id() == 0);
+        REQUIRE(resp.token.partition_uuid() == 0);
+        REQUIRE(resp.token.sequence_number() == 0);
+        REQUIRE(resp.ctx.first_error_index() == 0);
         REQUIRE(resp.fields.size() == 1);
         REQUIRE(resp.fields[0].path == "a");
-        REQUIRE(resp.fields[0].status == couchbase::protocol::status::subdoc_path_exists);
+        REQUIRE(resp.fields[0].status == couchbase::key_value_status_code::subdoc_path_exists);
     }
 }
 
@@ -708,19 +727,19 @@ TEST_CASE("integration: upsert is cancelled immediately if the cluster was close
     test::utils::integration_test_guard 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") };
 
     {
-        couchbase::operations::upsert_request req{ id, basic_doc_json };
+        couchbase::core::operations::upsert_request req{ id, basic_doc_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE_FALSE(resp.ctx.ec());
     }
 
     test::utils::close_cluster(integration.cluster);
 
     {
-        couchbase::operations::upsert_request req{ id, basic_doc_json };
+        couchbase::core::operations::upsert_request req{ id, basic_doc_json };
         auto resp = test::utils::execute(integration.cluster, req);
-        REQUIRE(resp.ctx.ec == couchbase::error::network_errc::cluster_closed);
+        REQUIRE(resp.ctx.ec() == couchbase::errc::network::cluster_closed);
     }
 }