couchbase 4.1.1 → 4.1.2

package/deps/couchbase-transactions-cxx/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::cas cas;
+    couchbase::cas cas{};
 
     {
         couchbase::operations::insert_request req{ id, basic_doc_json };
@@ -260,7 +260,7 @@ TEST_CASE("integration: lock/unlock without lock time", "[integration]")
         REQUIRE_FALSE(resp.ctx.ec);
     }
 
-    couchbase::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::cas cas;
+    couchbase::cas cas{};
 
     {
         couchbase::operations::insert_request req{ id, basic_doc_json };
@@ -439,7 +439,7 @@ TEST_CASE("integration: cas replace", "[integration]")
 
     SECTION("incorrect")
     {
-        couchbase::operations::replace_request req{ id, "" };
+        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);
@@ -447,7 +447,7 @@ TEST_CASE("integration: cas replace", "[integration]")
 
     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
     {

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

@@ -358,8 +358,80 @@ TEST_CASE("integration: ping", "[integration]")
         integration.cluster->ping(
           "my_report_id", {}, {}, [barrier](couchbase::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::service_type::management) > 0);
+        REQUIRE(res.services[couchbase::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::service_type::query) > 0);
+        REQUIRE(res.services[couchbase::service_type::query].size() > 0);
+
+        REQUIRE(res.services.count(couchbase::service_type::search) > 0);
+        REQUIRE(res.services[couchbase::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);
+        }
+
+        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.id == "my_report_id");
         INFO(res.sdk)
         REQUIRE(res.sdk.find("cxx/") == 0);
     }
 }
+
+TEST_CASE("integration: ping allows to select services", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+
+    test::utils::open_bucket(integration.cluster, integration.ctx.bucket);
+
+    {
+        auto barrier = std::make_shared<std::promise<couchbase::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)); });
+        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::service_type::query) > 0);
+        REQUIRE(res.services[couchbase::service_type::query].size() > 0);
+    }
+}
+
+TEST_CASE("integration: ping allows to select bucket and opens it automatically", "[integration]")
+{
+    test::utils::integration_test_guard integration;
+
+    {
+        auto barrier = std::make_shared<std::promise<couchbase::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)); });
+        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);
+    }
+}

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

@@ -32,7 +32,7 @@ TEST_CASE("integration: durable operations", "[integration]")
             { "a", 1.0 },
             { "b", 2.0 },
         };
-        couchbase::operations::upsert_request req{ id, couchbase::utils::json::generate(value) };
+        couchbase::operations::upsert_request req{ id, couchbase::utils::json::generate_binary(value) };
         req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
@@ -44,7 +44,7 @@ TEST_CASE("integration: durable operations", "[integration]")
         const tao::json::value value = {
             { "foo", "bar" },
         };
-        couchbase::operations::replace_request req{ id, couchbase::utils::json::generate(value) };
+        couchbase::operations::replace_request req{ id, couchbase::utils::json::generate_binary(value) };
         req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
         auto resp = test::utils::execute(integration.cluster, req);
         INFO(resp.ctx.ec.message())
@@ -68,7 +68,7 @@ TEST_CASE("integration: durable operations", "[integration]")
         INFO(resp.ctx.ec.message())
         REQUIRE_FALSE(resp.ctx.ec);
         REQUIRE(!resp.cas.empty());
-        REQUIRE(resp.value == R"({"foo":"bar","baz":42})");
+        REQUIRE(resp.value == couchbase::utils::to_binary(R"({"foo":"bar","baz":42})"));
     }
     {
         couchbase::operations::remove_request req{ id };