couchbase 3.4.3 → 3.4.4

data/ext/couchbase/test/test_transaction_public_async_api.cxx

@@ -32,7 +32,7 @@ async_options()
     return cfg;
 }
 
-TEST_CASE("can async get", "[transactions]")
+TEST_CASE("transactions public async API: can async get", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -62,7 +62,7 @@ TEST_CASE("can async get", "[transactions]")
     f.get();
 }
 
-TEST_CASE("can get fail as expected", "[transactions]")
+TEST_CASE("transactions public async API: can get fail as expected", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -85,7 +85,7 @@ TEST_CASE("can get fail as expected", "[transactions]")
       async_options());
     f.get();
 }
-TEST_CASE("can async remove", "[transactions]")
+TEST_CASE("transactions public async API: can async remove", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -114,7 +114,7 @@ TEST_CASE("can async remove", "[transactions]")
     f.get();
 }
 
-TEST_CASE("async remove with bad cas fails as expected", "[transactions]")
+TEST_CASE("transactions public async API: async remove with bad cas fails as expected", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -144,7 +144,8 @@ TEST_CASE("async remove with bad cas fails as expected", "[transactions]")
       async_options());
     f.get();
 }
-TEST_CASE("can async insert", "[transactions]")
+
+TEST_CASE("transactions public async API: can async insert", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -168,7 +169,7 @@ TEST_CASE("can async insert", "[transactions]")
     f.get();
 }
 
-TEST_CASE("async insert fails when doc already exists, but doesn't rollback", "[transactions]")
+TEST_CASE("transactions public async API: async insert fails when doc already exists, but doesn't rollback", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -196,7 +197,7 @@ TEST_CASE("async insert fails when doc already exists, but doesn't rollback", "[
     f.get();
 }
 
-TEST_CASE("can async replace", "[transactions]")
+TEST_CASE("transactions public async API: can async replace", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -227,7 +228,7 @@ TEST_CASE("can async replace", "[transactions]")
       async_options());
     f.get();
 }
-TEST_CASE("async replace fails as expected with bad cas", "[transactions]")
+TEST_CASE("transactions public async API: async replace fails as expected with bad cas", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -259,7 +260,7 @@ TEST_CASE("async replace fails as expected with bad cas", "[transactions]")
     f.get();
 }
 
-TEST_CASE("uncaught exception will rollback", "[transactions]")
+TEST_CASE("transactions public async API: uncaught exception will rollback", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -293,7 +294,7 @@ TEST_CASE("uncaught exception will rollback", "[transactions]")
     f.get();
 }
 
-TEST_CASE("can set transaction options", "[transactions]")
+TEST_CASE("transactions public async API: can set transaction options", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -334,7 +335,7 @@ TEST_CASE("can set transaction options", "[transactions]")
     f.get();
 }
 
-TEST_CASE("can do mutating query", "[transactions]")
+TEST_CASE("transactions public async API: can do mutating query", "[transactions]")
 {
 
     test::utils::integration_test_guard integration;
@@ -360,7 +361,7 @@ TEST_CASE("can do mutating query", "[transactions]")
     f.get();
 }
 
-TEST_CASE("some query errors rollback", "[transactions]")
+TEST_CASE("transactions public async API: some query errors rollback", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 

data/ext/couchbase/test/test_transaction_public_blocking_api.cxx

@@ -94,7 +94,7 @@ upsert_scope_and_collection(std::shared_ptr<couchbase::core::cluster> cluster,
     }
 }
 
-TEST_CASE("can get", "[transactions]")
+TEST_CASE("transactions public blocking API: can get", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -118,7 +118,7 @@ TEST_CASE("can get", "[transactions]")
     CHECK_FALSE(tx_err.ec());
 }
 
-TEST_CASE("get returns error if doc doesn't exist", "[transactions]")
+TEST_CASE("transactions public blocking API: get returns error if doc doesn't exist", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -137,7 +137,7 @@ TEST_CASE("get returns error if doc doesn't exist", "[transactions]")
     CHECK_FALSE(tx_err.ec());
 }
 
-TEST_CASE("can insert", "[transactions]")
+TEST_CASE("transactions public blocking API: can insert", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -165,7 +165,7 @@ TEST_CASE("can insert", "[transactions]")
     REQUIRE(final_doc.content_as<tao::json::value>() == content);
 }
 
-TEST_CASE("insert has error as expected when doc already exists", "[transactions]")
+TEST_CASE("transactions public blocking API: insert has error as expected when doc already exists", "[transactions]")
 {
 
     test::utils::integration_test_guard integration;
@@ -193,7 +193,7 @@ TEST_CASE("insert has error as expected when doc already exists", "[transactions
     REQUIRE(final_doc.content_as<tao::json::value>() == content);
 }
 
-TEST_CASE("can replace", "[transactions]")
+TEST_CASE("transactions public blocking API: can replace", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -225,7 +225,7 @@ TEST_CASE("can replace", "[transactions]")
             couchbase::core::utils::json::generate_binary(new_content));
 }
 
-TEST_CASE("replace fails as expected with bad cas", "[transactions]")
+TEST_CASE("transactions public blocking API: replace fails as expected with bad cas", "[transactions]")
 {
 
     test::utils::integration_test_guard integration;
@@ -255,7 +255,7 @@ TEST_CASE("replace fails as expected with bad cas", "[transactions]")
     REQUIRE(final_doc.content_as<tao::json::value>() == content);
 }
 
-TEST_CASE("can remove", "[transactions]")
+TEST_CASE("transactions public blocking API: can remove", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -280,7 +280,7 @@ TEST_CASE("can remove", "[transactions]")
     REQUIRE(final_err.ec() == couchbase::errc::key_value::document_not_found);
 }
 
-TEST_CASE("remove fails as expected with bad cas", "[transactions]")
+TEST_CASE("transactions public blocking API: remove fails as expected with bad cas", "[transactions]")
 {
 
     test::utils::integration_test_guard integration;
@@ -307,7 +307,7 @@ TEST_CASE("remove fails as expected with bad cas", "[transactions]")
     CHECK(tx_err.ec());
 }
 
-TEST_CASE("remove fails as expected with missing doc", "[transactions]")
+TEST_CASE("transactions public blocking API: remove fails as expected with missing doc", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -331,7 +331,7 @@ TEST_CASE("remove fails as expected with missing doc", "[transactions]")
     CHECK(tx_err.cause() == couchbase::errc::transaction_op::unknown);
 }
 
-TEST_CASE("uncaught exception in lambda will rollback without retry", "[transactions]")
+TEST_CASE("transactions public blocking API: uncaught exception in lambda will rollback without retry", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -352,7 +352,7 @@ TEST_CASE("uncaught exception in lambda will rollback without retry", "[transact
     CHECK(tx_err.cause() == couchbase::errc::transaction_op::unknown);
 }
 
-TEST_CASE("can pass per-transaction configs", "[transactions]")
+TEST_CASE("transactions public blocking API: can pass per-transaction configs", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -386,7 +386,7 @@ TEST_CASE("can pass per-transaction configs", "[transactions]")
     CHECK(tx_err.ec());
 }
 
-TEST_CASE("can do simple query", "[transactions]")
+TEST_CASE("transactions public blocking API: can do simple query", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -407,7 +407,7 @@ TEST_CASE("can do simple query", "[transactions]")
     CHECK_FALSE(result.transaction_id.empty());
 }
 
-TEST_CASE("can do simple mutating query", "[transactions]")
+TEST_CASE("transactions public blocking API: can do simple mutating query", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -430,7 +430,7 @@ TEST_CASE("can do simple mutating query", "[transactions]")
     CHECK(final_doc.content_as<tao::json::value>().at("some_number") == 10);
 }
 
-TEST_CASE("some query errors don't force rollback", "[transactions]")
+TEST_CASE("transactions public blocking API: some query errors don't force rollback", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -455,7 +455,7 @@ TEST_CASE("some query errors don't force rollback", "[transactions]")
     CHECK(final_doc.content_as<tao::json::value>() == content);
 }
 
-TEST_CASE("some query errors do rollback", "[transactions]")
+TEST_CASE("transactions public blocking API: some query errors do rollback", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -484,7 +484,7 @@ TEST_CASE("some query errors do rollback", "[transactions]")
     CHECK(doc2.cas().empty());
 }
 
-TEST_CASE("some query errors are seen immediately", "[transactions]")
+TEST_CASE("transactions public blocking API: some query errors are seen immediately", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -503,7 +503,7 @@ TEST_CASE("some query errors are seen immediately", "[transactions]")
     CHECK(result.unstaging_complete);
 }
 
-TEST_CASE("can query from a scope", "[transactions]")
+TEST_CASE("transactions public blocking API: can query from a scope", "[transactions]")
 {
     const std::string new_scope_name("newscope");
     const std::string new_coll_name("newcoll");
@@ -529,9 +529,15 @@ TEST_CASE("can query from a scope", "[transactions]")
       txn_opts());
     CHECK_FALSE(tx_err.ec());
     CHECK_FALSE(result.transaction_id.empty());
+
+    {
+        couchbase::core::operations::management::scope_drop_request req{ integration.ctx.bucket, new_scope_name };
+        auto resp = test::utils::execute(integration.cluster, req);
+        REQUIRE_SUCCESS(resp.ctx.ec);
+    }
 }
 
-TEST_CASE("can get doc from bucket not yet opened", "[transactions]")
+TEST_CASE("transactions public blocking API: can get doc from bucket not yet opened", "[transactions]")
 {
 
     auto id = test::utils::uniq_id("txn");
@@ -559,7 +565,7 @@ TEST_CASE("can get doc from bucket not yet opened", "[transactions]")
     });
 }
 
-TEST_CASE("can insert doc into bucket not yet opened", "[transactions]")
+TEST_CASE("transactions public blocking API: can insert doc into bucket not yet opened", "[transactions]")
 {
     test::utils::integration_test_guard integration;
 
@@ -585,7 +591,7 @@ TEST_CASE("can insert doc into bucket not yet opened", "[transactions]")
     });
 }
 
-TEST_CASE("can replace doc in bucket not yet opened", "[transactions]")
+TEST_CASE("transactions public blocking API: can replace doc in bucket not yet opened", "[transactions]")
 {
 
     auto id = test::utils::uniq_id("txn");
@@ -620,7 +626,7 @@ TEST_CASE("can replace doc in bucket not yet opened", "[transactions]")
     });
 }
 
-TEST_CASE("can remove doc in bucket not yet opened", "[transactions]")
+TEST_CASE("transactions public blocking API: can remove doc in bucket not yet opened", "[transactions]")
 {
 
     auto id = test::utils::uniq_id("txn");

data/ext/couchbase/test/test_unit_connection_string.cxx

@@ -416,4 +416,33 @@ TEST_CASE("unit: connection string", "[unit]")
         CHECK(couchbase::core::utils::parse_connection_string("couchbase://2001:db8:85a3:8d3:1319:8a2e:370:7348").error.value() ==
               R"(failed to parse connection string (column: 18, trailer: "db8:85a3:8d3:1319:8a2e:370:7348"))");
     }
+
+    SECTION("parsing warnings")
+    {
+        auto spec = couchbase::core::utils::parse_connection_string("couchbase://127.0.0.1?kv_timeout=42&foo=bar");
+        CHECK(spec.warnings == std::vector<std::string>{
+                                 R"(unknown parameter "foo" in connection string (value "bar"))",
+                               });
+
+        spec = couchbase::core::utils::parse_connection_string("couchbase://127.0.0.1?enable_dns_srv=maybe&ip_protocol=yes");
+        CHECK(spec.warnings ==
+              std::vector<std::string>{
+                R"(unable to parse "enable_dns_srv" parameter in connection string (value "maybe" cannot be interpreted as a boolean))",
+                R"(unable to parse "ip_protocol" parameter in connection string (value "yes" is not a valid IP protocol preference))",
+              });
+
+        spec = couchbase::core::utils::parse_connection_string("couchbase://localhost:8091=http;127.0.0.1=mcd/default?enable_dns_srv=true");
+        CHECK(
+          spec.warnings ==
+          std::vector<std::string>{
+            R"(parameter "enable_dns_srv" requires single entry in bootstrap nodes list of the connection string, ignoring (value "true"))",
+          });
+
+        spec = couchbase::core::utils::parse_connection_string(
+          "couchbase://localhost?query_timeout=10000&kv_timeout=true&management_timeout=11000");
+        std::string warning_prefix = R"(unable to parse "kv_timeout" parameter in connection string (value "true" is not a number))";
+        CHECK(spec.warnings.at(0).substr(0, warning_prefix.size()) == warning_prefix);
+        CHECK(spec.options.query_timeout == std::chrono::milliseconds(10000));
+        CHECK(spec.options.management_timeout == std::chrono::milliseconds(11000));
+    }
 }

data/ext/couchbase/test/test_unit_query.cxx

@@ -0,0 +1,75 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023 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 "utils/move_only_context.hxx"
+
+#include "core/operations/document_query.hxx"
+
+couchbase::core::http_context
+make_http_context(couchbase::core::topology::configuration& config)
+{
+    static couchbase::core::query_cache query_cache{};
+    static couchbase::core::cluster_options cluster_options{};
+    std::string hostname{};
+    std::uint16_t port{};
+    couchbase::core::http_context ctx{ config, cluster_options, query_cache, hostname, port };
+    return ctx;
+}
+
+TEST_CASE("unit: query with read from replica", "[unit]")
+{
+    couchbase::core::topology::configuration config{};
+    config.cluster_capabilities.insert(couchbase::core::cluster_capability::n1ql_read_from_replica);
+    auto ctx = make_http_context(config);
+
+    SECTION("use_replica true")
+    {
+        couchbase::core::io::http_request http_req;
+        couchbase::core::operations::query_request req{};
+        req.use_replica = true;
+        auto ec = req.encode_to(http_req, ctx);
+        REQUIRE_SUCCESS(ec);
+        auto body = couchbase::core::utils::json::parse(http_req.body);
+        REQUIRE(body.is_object());
+        REQUIRE(body.get_object().at("use_replica").get_string() == "on");
+    }
+
+    SECTION("use_replica false")
+    {
+        couchbase::core::io::http_request http_req;
+        couchbase::core::operations::query_request req{};
+        req.use_replica = false;
+        auto ec = req.encode_to(http_req, ctx);
+        REQUIRE_SUCCESS(ec);
+        auto body = couchbase::core::utils::json::parse(http_req.body);
+        REQUIRE(body.is_object());
+        REQUIRE(body.get_object().at("use_replica").get_string() == "off");
+    }
+
+    SECTION("use_replica not set")
+    {
+        couchbase::core::io::http_request http_req;
+        couchbase::core::operations::query_request req{};
+        auto ec = req.encode_to(http_req, ctx);
+        REQUIRE_SUCCESS(ec);
+        auto body = couchbase::core::utils::json::parse(http_req.body);
+        REQUIRE(body.is_object());
+        REQUIRE_FALSE(body.get_object().count("use_replica"));
+    }
+}