couchbase 4.0.0 → 4.1.2

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

@@ -0,0 +1,260 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "test_helper_integration.hxx"
+#include <couchbase/operations/management/analytics.hxx>
+#include <couchbase/operations/management/collection_create.hxx>
+#include <couchbase/operations/management/scope_create.hxx>
+
+TEST_CASE("integration: analytics query")
+{
+    test::utils::integration_test_guard integration;
+
+    if (!integration.cluster_version().supports_analytics()) {
+        return;
+    }
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    auto dataset_name = test::utils::uniq_id("dataset");
+
+    {
+        couchbase::operations::management::analytics_dataset_create_request req{};
+        req.dataset_name = dataset_name;
+        req.bucket_name = integration.ctx.bucket;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+    }
+
+    {
+        couchbase::operations::management::analytics_link_connect_request req{};
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+    }
+
+    auto key = test::utils::uniq_id("key");
+    auto test_value = test::utils::uniq_id("value");
+    auto value = couchbase::utils::json::generate({ { "testkey", test_value } });
+    {
+        auto id = couchbase::document_id(integration.ctx.bucket, "_default", "_default", key);
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(value) };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+    }
+
+    SECTION("simple query")
+    {
+        couchbase::operations::analytics_response resp{};
+        REQUIRE(test::utils::wait_until([&]() {
+            couchbase::operations::analytics_request req{};
+            req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value);
+            resp = test::utils::execute(integration.cluster, req);
+            return resp.rows.size() == 1;
+        }));
+        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE(resp.rows[0] == value);
+        REQUIRE_FALSE(resp.meta.request_id.empty());
+        REQUIRE_FALSE(resp.meta.client_context_id.empty());
+        REQUIRE_FALSE(resp.meta.status.empty());
+    }
+
+    SECTION("positional params")
+    {
+        couchbase::operations::analytics_response resp{};
+        REQUIRE(test::utils::wait_until([&]() {
+            couchbase::operations::analytics_request req{};
+            req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = ?)", dataset_name);
+            req.positional_parameters.emplace_back(couchbase::json_string(couchbase::utils::json::generate(test_value)));
+            resp = test::utils::execute(integration.cluster, req);
+            return resp.rows.size() == 1;
+        }));
+        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE(resp.rows[0] == value);
+    }
+
+    SECTION("named params")
+    {
+        couchbase::operations::analytics_response resp{};
+        REQUIRE(test::utils::wait_until([&]() {
+            couchbase::operations::analytics_request req{};
+            req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name);
+            req.named_parameters["testkey"] = couchbase::json_string(couchbase::utils::json::generate(test_value));
+            resp = test::utils::execute(integration.cluster, req);
+            return resp.rows.size() == 1;
+        }));
+        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE(resp.rows[0] == value);
+    }
+
+    SECTION("named params preformatted")
+    {
+        couchbase::operations::analytics_response resp{};
+        REQUIRE(test::utils::wait_until([&]() {
+            couchbase::operations::analytics_request req{};
+            req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name);
+            req.named_parameters["$testkey"] = couchbase::json_string(couchbase::utils::json::generate(test_value));
+            resp = test::utils::execute(integration.cluster, req);
+            return resp.rows.size() == 1;
+        }));
+        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE(resp.rows[0] == value);
+    }
+
+    SECTION("raw")
+    {
+        couchbase::operations::analytics_response resp{};
+        REQUIRE(test::utils::wait_until([&]() {
+            couchbase::operations::analytics_request req{};
+            req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = $testkey)", dataset_name);
+            req.raw["$testkey"] = couchbase::json_string(couchbase::utils::json::generate(test_value));
+            resp = test::utils::execute(integration.cluster, req);
+            return resp.rows.size() == 1;
+        }));
+        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE(resp.rows[0] == value);
+    }
+
+    SECTION("consistency")
+    {
+        couchbase::operations::analytics_request req{};
+        req.statement = fmt::format(R"(SELECT testkey FROM `Default`.`{}` WHERE testkey = "{}")", dataset_name, test_value);
+        req.scan_consistency = couchbase::analytics_scan_consistency::request_plus;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+        REQUIRE(resp.rows.size() == 1);
+        REQUIRE(resp.rows[0] == value);
+    }
+
+    SECTION("readonly")
+    {
+        couchbase::operations::analytics_request req{};
+        req.statement = fmt::format("DROP DATASET Default.`{}`", dataset_name);
+        req.readonly = true;
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE(resp.ctx.ec == couchbase::error::common_errc::internal_server_failure);
+    }
+
+    {
+        couchbase::operations::management::analytics_dataset_drop_request req{};
+        req.dataset_name = dataset_name;
+        test::utils::execute(integration.cluster, req);
+    }
+}
+
+TEST_CASE("integration: analytics scope query")
+{
+    test::utils::integration_test_guard integration;
+
+    if (!integration.cluster_version().supports_analytics() || !integration.cluster_version().supports_collections()) {
+        return;
+    }
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    auto scope_name = test::utils::uniq_id("scope");
+    auto collection_name = test::utils::uniq_id("collection");
+
+    {
+        couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
+    }
+
+    {
+        couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
+    }
+
+    {
+        couchbase::operations::analytics_request req{};
+        req.statement =
+          fmt::format("ALTER COLLECTION `{}`.`{}`.`{}` ENABLE ANALYTICS", integration.ctx.bucket, scope_name, collection_name);
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+    }
+
+    auto key = test::utils::uniq_id("key");
+    auto test_value = test::utils::uniq_id("value");
+    auto value = couchbase::utils::json::generate({ { "testkey", test_value } });
+    {
+        auto id = couchbase::document_id(integration.ctx.bucket, scope_name, collection_name, key);
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(value) };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_FALSE(resp.ctx.ec);
+    }
+
+    couchbase::operations::analytics_response resp{};
+    REQUIRE(test::utils::wait_until([&]() {
+        couchbase::operations::analytics_request req{};
+        req.statement = fmt::format(R"(SELECT testkey FROM `{}` WHERE testkey = "{}")", collection_name, test_value);
+        req.bucket_name = integration.ctx.bucket;
+        req.scope_name = scope_name;
+        resp = test::utils::execute(integration.cluster, req);
+        return resp.rows.size() == 1;
+    }));
+    REQUIRE_FALSE(resp.ctx.ec);
+    REQUIRE(resp.rows[0] == value);
+
+    {
+        couchbase::operations::management::scope_drop_request req{ integration.ctx.bucket, scope_name };
+        test::utils::execute(integration.cluster, req);
+    }
+}
+
+couchbase::http_context
+make_http_context()
+{
+    couchbase::topology::configuration config{};
+    couchbase::query_cache query_cache{};
+    couchbase::cluster_options cluster_options{};
+    std::string hostname{};
+    std::uint16_t port{};
+    couchbase::http_context ctx{ config, cluster_options, query_cache, hostname, port };
+    return ctx;
+}
+
+TEST_CASE("unit: analytics query")
+{
+    SECTION("priority true")
+    {
+        couchbase::io::http_request http_req;
+        auto ctx = make_http_context();
+        couchbase::operations::analytics_request req{};
+        req.priority = true;
+        auto ec = req.encode_to(http_req, ctx);
+        REQUIRE_FALSE(ec);
+        auto priority_header = http_req.headers.find("analytics-priority");
+        REQUIRE(priority_header != http_req.headers.end());
+        REQUIRE(priority_header->second == "-1");
+    }
+
+    SECTION("priority false")
+    {
+        couchbase::io::http_request http_req;
+        auto ctx = make_http_context();
+        couchbase::operations::analytics_request req{};
+        req.priority = false;
+        auto ec = req.encode_to(http_req, ctx);
+        REQUIRE_FALSE(ec);
+        REQUIRE(http_req.headers.find("analytics-priority") == http_req.headers.end());
+    }
+}

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

@@ -27,7 +27,7 @@ TEST_CASE("integration: increment", "[integration]")
     SECTION("key exists")
     {
         {
-            couchbase::operations::insert_request req{ id, "0" };
+            couchbase::operations::insert_request req{ id, couchbase::utils::to_binary("0") };
             auto resp = test::utils::execute(integration.cluster, req);
             REQUIRE_FALSE(resp.ctx.ec);
         }
@@ -50,6 +50,18 @@ TEST_CASE("integration: increment", "[integration]")
         REQUIRE_FALSE(resp.ctx.ec);
         REQUIRE(resp.content == 10);
     }
+
+    if (integration.cluster_version().supports_enhanced_durability()) {
+        SECTION("durability")
+        {
+            couchbase::operations::increment_request req{ id };
+            req.initial_value = 2;
+            req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE(resp.content == 2);
+        }
+    }
 }
 
 TEST_CASE("integration: decrement", "[integration]")
@@ -62,7 +74,7 @@ TEST_CASE("integration: decrement", "[integration]")
     SECTION("key exists")
     {
         {
-            couchbase::operations::insert_request req{ id, "20" };
+            couchbase::operations::insert_request req{ id, couchbase::utils::to_binary("20") };
             auto resp = test::utils::execute(integration.cluster, req);
             REQUIRE_FALSE(resp.ctx.ec);
         }
@@ -85,4 +97,16 @@ TEST_CASE("integration: decrement", "[integration]")
         REQUIRE_FALSE(resp.ctx.ec);
         REQUIRE(resp.content == 10);
     }
+
+    if (integration.cluster_version().supports_enhanced_durability()) {
+        SECTION("durability")
+        {
+            couchbase::operations::decrement_request req{ id };
+            req.initial_value = 2;
+            req.durability_level = couchbase::protocol::durability_level::persist_to_majority;
+            auto resp = test::utils::execute(integration.cluster, req);
+            REQUIRE_FALSE(resp.ctx.ec);
+            REQUIRE(resp.content == 2);
+        }
+    }
 }

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

@@ -17,7 +17,8 @@
 
 #include "test_helper_integration.hxx"
 
-#include <couchbase/protocol/cas_fmt.hxx>
+#include <couchbase/cas_fmt.hxx>
+#include <couchbase/utils/binary.hxx>
 
 TEST_CASE("integration: append", "[integration]")
 {
@@ -27,7 +28,7 @@ TEST_CASE("integration: append", "[integration]")
 
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
     {
-        couchbase::operations::upsert_request req{ id, "world" };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary("world") };
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
@@ -37,7 +38,7 @@ TEST_CASE("integration: append", "[integration]")
         REQUIRE(resp.token.sequence_number != 0);
     }
     {
-        couchbase::operations::append_request req{ id, "!" };
+        couchbase::operations::append_request req{ id, couchbase::utils::to_binary("!") };
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
@@ -51,8 +52,7 @@ TEST_CASE("integration: append", "[integration]")
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
         REQUIRE(!resp.cas.empty());
-        INFO("value=" << resp.value)
-        REQUIRE(resp.value == "world!");
+        REQUIRE(resp.value == couchbase::utils::to_binary("world!"));
     }
 }
 
@@ -64,7 +64,7 @@ TEST_CASE("integration: prepend", "[integration]")
 
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
     {
-        couchbase::operations::upsert_request req{ id, "world" };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary("world") };
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
@@ -73,7 +73,7 @@ TEST_CASE("integration: prepend", "[integration]")
         REQUIRE(resp.token.sequence_number != 0);
     }
     {
-        couchbase::operations::prepend_request req{ id, "Hello, " };
+        couchbase::operations::prepend_request req{ id, couchbase::utils::to_binary("Hello, ") };
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
@@ -87,8 +87,7 @@ TEST_CASE("integration: prepend", "[integration]")
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
         REQUIRE(!resp.cas.empty());
-        INFO("value=" << resp.value)
-        REQUIRE(resp.value == "Hello, world");
+        REQUIRE(resp.value == couchbase::utils::to_binary("Hello, world"));
     }
 }
 
@@ -101,14 +100,14 @@ TEST_CASE("integration: binary ops on missing document", "[integration]")
 
     SECTION("append")
     {
-        couchbase::operations::append_request req{ id, "" };
+        couchbase::operations::append_request req{ id, couchbase::utils::to_binary("") };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
     }
 
     SECTION("prepend")
     {
-        couchbase::operations::prepend_request req{ id, "" };
+        couchbase::operations::prepend_request req{ id, couchbase::utils::to_binary("") };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
     }

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

@@ -43,7 +43,7 @@ TEST_CASE("integration: missing scope and collection", "[integration]")
             { "a", 1.0 },
             { "b", 2.0 },
         };
-        couchbase::operations::insert_request req{ id, couchbase::utils::json::generate(value) };
+        couchbase::operations::insert_request req{ id, couchbase::utils::json::generate_binary(value) };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::common_errc::scope_not_found);
     }
@@ -64,7 +64,7 @@ TEST_CASE("integration: missing scope and collection", "[integration]")
             { "a", 1.0 },
             { "b", 2.0 },
         };
-        couchbase::operations::insert_request req{ id, couchbase::utils::json::generate(value) };
+        couchbase::operations::insert_request req{ id, couchbase::utils::json::generate_binary(value) };
         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_collection_outdated) == 1);
@@ -89,22 +89,20 @@ TEST_CASE("integration: get and insert non default scope and collection", "[inte
         couchbase::operations::management::scope_create_request req{ integration.ctx.bucket, scope_name };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
     }
 
-    std::uint64_t current_manifest_uid = 0;
     {
         couchbase::operations::management::collection_create_request req{ integration.ctx.bucket, scope_name, collection_name };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        current_manifest_uid = resp.uid;
+        auto created = test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, resp.uid);
+        REQUIRE(created);
     }
 
-    auto created =
-      test::utils::wait_until_collection_manifest_propagated(integration.cluster, integration.ctx.bucket, current_manifest_uid);
-    REQUIRE(created);
-
     {
-        couchbase::operations::insert_request req{ id, key };
+        couchbase::operations::insert_request req{ id, couchbase::utils::to_binary(key) };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
     }
@@ -113,7 +111,7 @@ TEST_CASE("integration: get and insert non default scope and collection", "[inte
         couchbase::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == key);
+        REQUIRE(resp.value == couchbase::utils::to_binary(key));
     }
 }
 
@@ -148,7 +146,7 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
     }
 
     {
-        couchbase::operations::insert_request req{ id, key };
+        couchbase::operations::insert_request req{ id, couchbase::utils::to_binary(key) };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
     }
@@ -157,7 +155,7 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
         couchbase::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == key);
+        REQUIRE(resp.value == couchbase::utils::to_binary(key));
     }
 
     {
@@ -169,7 +167,7 @@ TEST_CASE("integration: insert into dropped scope", "[integration]")
     }
 
     {
-        couchbase::operations::upsert_request req{ id, key };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(key) };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::common_errc::scope_not_found);
     }

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

@@ -37,6 +37,36 @@ TEST_CASE("integration: connecting with empty bootstrap nodes list", "[integrati
     io_thread.join();
 }
 
+TEST_CASE("integration: connecting with unresponsive first node in bootstrap nodes list", "[integration]")
+{
+    test::utils::init_logger();
+    asio::io_context io{};
+    auto ctx = test::utils::test_context::load_from_environment();
+    if (ctx.deployment == test::utils::deployment_type::capella) {
+        // This breaks SRV assumptions (only one host in connection string)
+        return;
+    }
+    auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
+    REQUIRE_FALSE(connstr.bootstrap_nodes.empty());
+    connstr.bootstrap_nodes.insert(connstr.bootstrap_nodes.begin(),
+                                   couchbase::utils::connection_string::node{
+                                     "example.com",
+                                     11210,
+                                     couchbase::utils::connection_string::address_type::dns,
+                                     couchbase::utils::connection_string::bootstrap_mode::gcccp,
+                                   });
+    auto origin = couchbase::origin(ctx.build_auth(), connstr);
+    auto cluster = couchbase::cluster::create(io);
+    auto io_thread = std::thread([&io]() { io.run(); });
+    auto barrier = std::make_shared<std::promise<std::error_code>>();
+    auto f = barrier->get_future();
+    cluster->open(origin, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+    auto rc = f.get();
+    REQUIRE_FALSE(rc);
+    test::utils::close_cluster(cluster);
+    io_thread.join();
+}
+
 TEST_CASE("integration: can connect with handler capturing non-copyable object", "[integration]")
 {
     test::utils::integration_test_guard integration;
@@ -101,7 +131,7 @@ TEST_CASE("integration: destroy cluster without waiting for close completion", "
     // hit KV
     {
         couchbase::document_id id{ ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
-        couchbase::operations::upsert_request req{ id, "{{}}" };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary("{{}}") };
         auto resp = test::utils::execute(cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
     }

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

@@ -23,7 +23,7 @@ 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::utils::json::generate_binary(basic_doc);
 
 TEST_CASE("integration: crud on default collection", "[integration]")
 {
@@ -53,7 +53,7 @@ TEST_CASE("integration: crud on default collection", "[integration]")
     // update
     {
         auto doc = basic_doc;
-        auto json = couchbase::utils::json::generate(doc);
+        auto json = couchbase::utils::json::generate_binary(doc);
         doc["a"] = 2.0;
 
         {
@@ -170,7 +170,7 @@ TEST_CASE("integration: pessimistic locking", "[integration]")
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("locking") };
     uint32_t lock_time = 10;
 
-    couchbase::protocol::cas cas;
+    couchbase::cas cas{};
 
     {
         couchbase::operations::insert_request req{ id, basic_doc_json };
@@ -209,7 +209,7 @@ TEST_CASE("integration: pessimistic locking", "[integration]")
     // but unlock operation is not retried in this case, because it would never have succeeded
     {
         couchbase::operations::unlock_request req{ id };
-        req.cas = couchbase::protocol::cas{ cas.value - 1 };
+        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);
@@ -260,7 +260,7 @@ TEST_CASE("integration: lock/unlock without lock time", "[integration]")
         REQUIRE_FALSE(resp.ctx.ec);
     }
 
-    couchbase::protocol::cas cas;
+    couchbase::cas cas{};
 
     {
         couchbase::operations::get_and_lock_request req{ id };
@@ -380,7 +380,7 @@ TEST_CASE("integration: zero length value", "[integration]")
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("zero_length_value") };
 
     {
-        couchbase::operations::insert_request req{ id, "" };
+        couchbase::operations::insert_request req{ id, couchbase::utils::to_binary("") };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
     }
@@ -389,7 +389,7 @@ TEST_CASE("integration: zero length value", "[integration]")
         couchbase::operations::get_request req{ id };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
-        REQUIRE(resp.value == "");
+        REQUIRE(resp.value == couchbase::utils::to_binary(""));
     }
 }
 
@@ -416,7 +416,7 @@ TEST_CASE("integration: ops on missing document", "[integration]")
 
     SECTION("replace")
     {
-        couchbase::operations::replace_request req{ id, "" };
+        couchbase::operations::replace_request req{ id, couchbase::utils::to_binary("") };
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE(resp.ctx.ec == couchbase::error::key_value_errc::document_not_found);
     }
@@ -428,7 +428,7 @@ TEST_CASE("integration: cas replace", "[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::protocol::cas cas;
+    couchbase::cas cas{};
 
     {
         couchbase::operations::insert_request req{ id, basic_doc_json };
@@ -439,15 +439,15 @@ TEST_CASE("integration: cas replace", "[integration]")
 
     SECTION("incorrect")
     {
-        couchbase::operations::replace_request req{ id, "" };
-        req.cas = couchbase::protocol::cas{ cas.value + 1 };
+        couchbase::operations::replace_request req{ id, couchbase::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);
     }
 
     SECTION("correct")
     {
-        couchbase::operations::replace_request req{ id, "" };
+        couchbase::operations::replace_request req{ id, couchbase::utils::to_binary("") };
         req.cas = cas;
         auto resp = test::utils::execute(integration.cluster, req);
         REQUIRE_FALSE(resp.ctx.ec);
@@ -466,7 +466,7 @@ TEST_CASE("integration: upsert preserve expiry", "[integration]")
 
     couchbase::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";
+    const auto* expiry_path = "$document.exptime";
 
     {
         couchbase::operations::upsert_request req{ id, basic_doc_json };
@@ -518,7 +518,7 @@ TEST_CASE("integration: upsert with handler capturing non-copyable object", "[in
 
     {
         couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
-        couchbase::operations::upsert_request req{ id, R"({"foo":"bar"})" };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::to_binary(R"({"foo":"bar"})") };
         auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
         auto f = barrier->get_future();
         test::utils::move_only_context ctx("foobar");
@@ -540,7 +540,7 @@ TEST_CASE("integration: upsert may trigger snappy compression", "[integration]")
     test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
     couchbase::document_id id{ integration.ctx.bucket, "_default", "_default", test::utils::uniq_id("foo") };
 
-    std::string compressible_json = R"(
+    auto compressible_json = couchbase::utils::to_binary(R"(
 {
   "name": "Emmy-lou Dickerson",
   "age": 26,
@@ -569,7 +569,7 @@ TEST_CASE("integration: upsert may trigger snappy compression", "[integration]")
     ]
   }
 }
-)";
+)");
 
     // create
     {