couchbase 4.1.2 → 4.1.3

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

@@ -15,11 +15,12 @@
  *   limitations under the License.
  */
 
-#include "couchbase/logger/logger.hxx"
+#include "core/logger/logger.hxx"
+
+#include "test/utils/logger.hxx"
 #include "test_helper.hxx"
-#include "utils/logger.hxx"
 
-#include <couchbase/utils/json_streaming_lexer.hxx>
+#include "core/utils/json_streaming_lexer.hxx"
 
 struct query_result {
     std::error_code ec{};
@@ -45,11 +46,11 @@ null,1,false
 "status": "success"
 }
 )";
-    couchbase::utils::json::streaming_lexer lexer("/results/^", 4);
+    couchbase::core::utils::json::streaming_lexer lexer("/results/^", 4);
     query_result result{};
     lexer.on_row([&result](std::string&& row) {
         result.rows.emplace_back(std::move(row));
-        return couchbase::utils::json::stream_control::next_row;
+        return couchbase::core::utils::json::stream_control::next_row;
     });
     lexer.on_complete([&result](std::error_code ec, std::size_t number_of_rows, std::string&& meta) {
         result.ec = ec;
@@ -57,7 +58,7 @@ null,1,false
         result.meta = std::move(meta);
     });
     lexer.feed(chunk);
-    REQUIRE_FALSE(result.ec);
+    REQUIRE_SUCCESS(result.ec);
     REQUIRE(result.number_of_rows == 5);
     REQUIRE(result.rows.size() == 5);
     REQUIRE(result.meta == R"(
@@ -94,11 +95,11 @@ TEST_CASE("unit: json_streaming_lexer parse query result", "[unit]")
         R"(], "status": "success", "metrics": {"elapsedTime": "1.284307ms","executionTime": "1.231972ms","resultCount": 3,"resultSize": 1658,"serviceLoad": 3} })"
     };
 
-    couchbase::utils::json::streaming_lexer lexer("/results/^", 4);
+    couchbase::core::utils::json::streaming_lexer lexer("/results/^", 4);
     query_result result{};
     lexer.on_row([&result](std::string&& row) {
         result.rows.emplace_back(std::move(row));
-        return couchbase::utils::json::stream_control::next_row;
+        return couchbase::core::utils::json::stream_control::next_row;
     });
     lexer.on_complete([&result](std::error_code ec, std::size_t number_of_rows, std::string&& meta) {
         result.ec = ec;
@@ -108,7 +109,7 @@ TEST_CASE("unit: json_streaming_lexer parse query result", "[unit]")
     for (const auto& chunk : chunks) {
         lexer.feed(chunk);
     }
-    REQUIRE_FALSE(result.ec);
+    REQUIRE_SUCCESS(result.ec);
     REQUIRE(result.number_of_rows == 3);
     REQUIRE(result.rows.size() == 3);
     REQUIRE(result.meta == chunks[0] + chunks[4]);
@@ -125,11 +126,11 @@ TEST_CASE("unit: json_streaming_lexer parse query result in multiple chunks", "[
         R"(1,"#itemsOut":1,"#phaseSwitches":2,"execTime":"7.078µs"},"optimizer_estimates":{"cardinality":1,"cost":0.001,"fr_cost":0.001,"size":1}}]},"~versions":["7.1.0-N1QL","7.1.0-2534-enterprise"]},"optimizerEstimates": {"cardinality":1,"cost":0.001}}})"
     };
 
-    couchbase::utils::json::streaming_lexer lexer("/results/^", 4);
+    couchbase::core::utils::json::streaming_lexer lexer("/results/^", 4);
     query_result result{};
     lexer.on_row([&result](std::string&& row) {
         result.rows.emplace_back(std::move(row));
-        return couchbase::utils::json::stream_control::next_row;
+        return couchbase::core::utils::json::stream_control::next_row;
     });
     lexer.on_complete([&result](std::error_code ec, std::size_t number_of_rows, std::string&& meta) {
         result.ec = ec;
@@ -139,7 +140,7 @@ TEST_CASE("unit: json_streaming_lexer parse query result in multiple chunks", "[
     for (const auto& chunk : chunks) {
         lexer.feed(chunk);
     }
-    REQUIRE_FALSE(result.ec);
+    REQUIRE_SUCCESS(result.ec);
     REQUIRE(result.number_of_rows == 1);
     REQUIRE(result.rows.size() == 1);
 
@@ -163,11 +164,11 @@ TEST_CASE("unit: json_streaming_lexer parse chunked metadata trailer", "[unit]")
         /* 3 */
         R"("status": "success"})",
     };
-    couchbase::utils::json::streaming_lexer lexer("/results/^", 4);
+    couchbase::core::utils::json::streaming_lexer lexer("/results/^", 4);
     query_result result{};
     lexer.on_row([&result](std::string&& row) {
         result.rows.emplace_back(std::move(row));
-        return couchbase::utils::json::stream_control::next_row;
+        return couchbase::core::utils::json::stream_control::next_row;
     });
     lexer.on_complete([&result](std::error_code ec, std::size_t number_of_rows, std::string&& meta) {
         result.ec = ec;
@@ -177,7 +178,7 @@ TEST_CASE("unit: json_streaming_lexer parse chunked metadata trailer", "[unit]")
     for (const auto& chunk : chunks) {
         lexer.feed(chunk);
     }
-    REQUIRE_FALSE(result.ec);
+    REQUIRE_SUCCESS(result.ec);
     REQUIRE(result.number_of_rows == 1);
     REQUIRE(result.rows.size() == 1);
     const auto* expected_meta =
@@ -209,13 +210,13 @@ TEST_CASE("unit: json_streaming_lexer parse payload with missing results", "[uni
 	}
 }
 )";
-    couchbase::utils::json::streaming_lexer lexer("/results/^", 4);
+    couchbase::core::utils::json::streaming_lexer lexer("/results/^", 4);
     query_result result{};
     bool on_row_handler_executed = false;
     lexer.on_row([&result, &on_row_handler_executed](std::string&& row) {
         on_row_handler_executed = true;
         result.rows.emplace_back(std::move(row));
-        return couchbase::utils::json::stream_control::next_row;
+        return couchbase::core::utils::json::stream_control::next_row;
     });
     bool on_complete_handler_excecuted = false;
     lexer.on_complete([&result, &on_complete_handler_excecuted](std::error_code ec, std::size_t number_of_rows, std::string&& meta) {
@@ -227,7 +228,7 @@ TEST_CASE("unit: json_streaming_lexer parse payload with missing results", "[uni
     lexer.feed(chunk);
     REQUIRE_FALSE(on_row_handler_executed);
     REQUIRE(on_complete_handler_excecuted);
-    REQUIRE_FALSE(result.ec);
+    REQUIRE_SUCCESS(result.ec);
     REQUIRE(result.number_of_rows == 0);
     REQUIRE(result.rows.empty());
     REQUIRE(result.meta == chunk);

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

@@ -0,0 +1,210 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 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.hxx"
+
+#include <couchbase/codec/json_transcoder.hxx>
+
+#include <tao/json.hpp>
+
+TEST_CASE("unit: json_transcoder encodes primitives", "[unit]")
+{
+    {
+        /*
+         * echo -n '"hello, world"' \
+         *  | ruby -e 'puts ARGF.read.chars.map{|c| format("std::byte{0x%02x}", c.ord)}.join(", ")'
+         */
+        std::vector<std::byte> expected_data{
+            std::byte{ 0x22 }, std::byte{ 0x68 }, std::byte{ 0x65 }, std::byte{ 0x6c }, std::byte{ 0x6c },
+            std::byte{ 0x6f }, std::byte{ 0x2c }, std::byte{ 0x20 }, std::byte{ 0x77 }, std::byte{ 0x6f },
+            std::byte{ 0x72 }, std::byte{ 0x6c }, std::byte{ 0x64 }, std::byte{ 0x22 },
+        };
+        auto encoded = couchbase::codec::json_transcoder::encode("hello, world");
+        REQUIRE(encoded.data == expected_data);
+        REQUIRE(encoded.flags == couchbase::codec::codec_flags::json_common_flags);
+    }
+
+    {
+        /*
+         * echo -n '3.14' \
+         *  | ruby -e 'puts ARGF.read.chars.map{|c| format("std::byte{0x%02x}", c.ord)}.join(", ")'
+         */
+        std::vector<std::byte> expected_data{
+            std::byte{ 0x33 },
+            std::byte{ 0x2e },
+            std::byte{ 0x31 },
+            std::byte{ 0x34 },
+        };
+        auto encoded = couchbase::codec::json_transcoder::encode(3.14);
+        REQUIRE(encoded.data == expected_data);
+        REQUIRE(encoded.flags == couchbase::codec::codec_flags::json_common_flags);
+    }
+
+    {
+        /*
+         * echo -n 'true' \
+         *  | ruby -e 'puts ARGF.read.chars.map{|c| format("std::byte{0x%02x}", c.ord)}.join(", ")'
+         */
+        std::vector<std::byte> expected_data{
+            std::byte{ 0x74 },
+            std::byte{ 0x72 },
+            std::byte{ 0x75 },
+            std::byte{ 0x65 },
+        };
+        auto encoded = couchbase::codec::json_transcoder::encode(true);
+        REQUIRE(encoded.data == expected_data);
+        REQUIRE(encoded.flags == couchbase::codec::codec_flags::json_common_flags);
+    }
+}
+
+TEST_CASE("unit: json_transcoder decodes primitives", "[unit]")
+{
+    {
+        /*
+         * echo -n '"hello, world"' \
+         *  | ruby -e 'puts ARGF.read.chars.map{|c| format("std::byte{0x%02x}", c.ord)}.join(", ")'
+         */
+        std::vector<std::byte> encoded_data{
+            std::byte{ 0x22 }, std::byte{ 0x68 }, std::byte{ 0x65 }, std::byte{ 0x6c }, std::byte{ 0x6c },
+            std::byte{ 0x6f }, std::byte{ 0x2c }, std::byte{ 0x20 }, std::byte{ 0x77 }, std::byte{ 0x6f },
+            std::byte{ 0x72 }, std::byte{ 0x6c }, std::byte{ 0x64 }, std::byte{ 0x22 },
+        };
+        auto decoded =
+          couchbase::codec::json_transcoder::decode<std::string>({ encoded_data, couchbase::codec::codec_flags::json_common_flags });
+        REQUIRE(decoded == "hello, world");
+    }
+
+    {
+        /*
+         * echo -n '3.14' \
+         *  | ruby -e 'puts ARGF.read.chars.map{|c| format("std::byte{0x%02x}", c.ord)}.join(", ")'
+         */
+        std::vector<std::byte> encoded_data{
+            std::byte{ 0x33 },
+            std::byte{ 0x2e },
+            std::byte{ 0x31 },
+            std::byte{ 0x34 },
+        };
+        auto decoded =
+          couchbase::codec::json_transcoder::decode<double>({ encoded_data, couchbase::codec::codec_flags::json_common_flags });
+        REQUIRE(Approx(decoded) == 3.14);
+    }
+
+    {
+        /*
+         * echo -n 'true' \
+         *  | ruby -e 'puts ARGF.read.chars.map{|c| format("std::byte{0x%02x}", c.ord)}.join(", ")'
+         */
+        std::vector<std::byte> encoded_data{
+            std::byte{ 0x74 },
+            std::byte{ 0x72 },
+            std::byte{ 0x75 },
+            std::byte{ 0x65 },
+        };
+        auto decoded = couchbase::codec::json_transcoder::decode<bool>({ encoded_data, couchbase::codec::codec_flags::json_common_flags });
+        REQUIRE(decoded == true);
+    }
+}
+
+struct profile {
+    std::string username{};
+    std::string full_name{};
+    std::uint32_t birth_year{};
+};
+
+template<>
+struct tao::json::traits<profile> {
+    template<template<typename...> class Traits>
+    static void assign(tao::json::basic_value<Traits>& v, const profile& p)
+    {
+        v = {
+            { "username", p.username },
+            { "full_name", p.full_name },
+            { "birth_year", p.birth_year },
+        };
+    }
+
+    template<template<typename...> class Traits>
+    static profile as(const tao::json::basic_value<Traits>& v)
+    {
+        profile result;
+        const auto& object = v.get_object();
+        result.username = object.at("username").template as<std::string>();
+        result.full_name = object.at("full_name").template as<std::string>();
+        result.birth_year = object.at("birth_year").template as<std::uint32_t>();
+        return result;
+    }
+};
+
+TEST_CASE("unit: json_transcoder encodes user data", "[unit]")
+{
+    profile albert{ "this_guy_again", "Albert Einstein", 1879 };
+
+    /*
+     * echo -n '{"birth_year":1879,"full_name":"Albert Einstein", "username":"this_guy_again"}' \
+     *  | ruby -e 'puts ARGF.read.chars.map{|c| format("std::byte{0x%02x}", c.ord)}.join(", ")'
+     */
+    std::vector<std::byte> expected_data{
+        std::byte{ 0x7b }, std::byte{ 0x22 }, std::byte{ 0x62 }, std::byte{ 0x69 }, std::byte{ 0x72 }, std::byte{ 0x74 }, std::byte{ 0x68 },
+        std::byte{ 0x5f }, std::byte{ 0x79 }, std::byte{ 0x65 }, std::byte{ 0x61 }, std::byte{ 0x72 }, std::byte{ 0x22 }, std::byte{ 0x3a },
+        std::byte{ 0x31 }, std::byte{ 0x38 }, std::byte{ 0x37 }, std::byte{ 0x39 }, std::byte{ 0x2c }, std::byte{ 0x22 }, std::byte{ 0x66 },
+        std::byte{ 0x75 }, std::byte{ 0x6c }, std::byte{ 0x6c }, std::byte{ 0x5f }, std::byte{ 0x6e }, std::byte{ 0x61 }, std::byte{ 0x6d },
+        std::byte{ 0x65 }, std::byte{ 0x22 }, std::byte{ 0x3a }, std::byte{ 0x22 }, std::byte{ 0x41 }, std::byte{ 0x6c }, std::byte{ 0x62 },
+        std::byte{ 0x65 }, std::byte{ 0x72 }, std::byte{ 0x74 }, std::byte{ 0x20 }, std::byte{ 0x45 }, std::byte{ 0x69 }, std::byte{ 0x6e },
+        std::byte{ 0x73 }, std::byte{ 0x74 }, std::byte{ 0x65 }, std::byte{ 0x69 }, std::byte{ 0x6e }, std::byte{ 0x22 }, std::byte{ 0x2c },
+        std::byte{ 0x22 }, std::byte{ 0x75 }, std::byte{ 0x73 }, std::byte{ 0x65 }, std::byte{ 0x72 }, std::byte{ 0x6e }, std::byte{ 0x61 },
+        std::byte{ 0x6d }, std::byte{ 0x65 }, std::byte{ 0x22 }, std::byte{ 0x3a }, std::byte{ 0x22 }, std::byte{ 0x74 }, std::byte{ 0x68 },
+        std::byte{ 0x69 }, std::byte{ 0x73 }, std::byte{ 0x5f }, std::byte{ 0x67 }, std::byte{ 0x75 }, std::byte{ 0x79 }, std::byte{ 0x5f },
+        std::byte{ 0x61 }, std::byte{ 0x67 }, std::byte{ 0x61 }, std::byte{ 0x69 }, std::byte{ 0x6e }, std::byte{ 0x22 }, std::byte{ 0x7d },
+    };
+
+    auto encoded = couchbase::codec::json_transcoder::encode(albert);
+    REQUIRE(encoded.data == expected_data);
+    REQUIRE(encoded.flags == couchbase::codec::codec_flags::json_common_flags);
+}
+
+TEST_CASE("unit: json_transcoder decodes user data", "[unit]")
+{
+    /*
+     * echo -n '{"birth_year":1879,"full_name":"Albert Einstein", "username":"this_guy_again"}' \
+     *  | ruby -e 'puts ARGF.read.chars.map{|c| format("std::byte{0x%02x}", c.ord)}.join(", ")'
+     */
+    std::vector<std::byte> encoded_data{
+        std::byte{ 0x7b }, std::byte{ 0x22 }, std::byte{ 0x62 }, std::byte{ 0x69 }, std::byte{ 0x72 }, std::byte{ 0x74 }, std::byte{ 0x68 },
+        std::byte{ 0x5f }, std::byte{ 0x79 }, std::byte{ 0x65 }, std::byte{ 0x61 }, std::byte{ 0x72 }, std::byte{ 0x22 }, std::byte{ 0x3a },
+        std::byte{ 0x31 }, std::byte{ 0x38 }, std::byte{ 0x37 }, std::byte{ 0x39 }, std::byte{ 0x2c }, std::byte{ 0x22 }, std::byte{ 0x66 },
+        std::byte{ 0x75 }, std::byte{ 0x6c }, std::byte{ 0x6c }, std::byte{ 0x5f }, std::byte{ 0x6e }, std::byte{ 0x61 }, std::byte{ 0x6d },
+        std::byte{ 0x65 }, std::byte{ 0x22 }, std::byte{ 0x3a }, std::byte{ 0x22 }, std::byte{ 0x41 }, std::byte{ 0x6c }, std::byte{ 0x62 },
+        std::byte{ 0x65 }, std::byte{ 0x72 }, std::byte{ 0x74 }, std::byte{ 0x20 }, std::byte{ 0x45 }, std::byte{ 0x69 }, std::byte{ 0x6e },
+        std::byte{ 0x73 }, std::byte{ 0x74 }, std::byte{ 0x65 }, std::byte{ 0x69 }, std::byte{ 0x6e }, std::byte{ 0x22 }, std::byte{ 0x2c },
+        std::byte{ 0x22 }, std::byte{ 0x75 }, std::byte{ 0x73 }, std::byte{ 0x65 }, std::byte{ 0x72 }, std::byte{ 0x6e }, std::byte{ 0x61 },
+        std::byte{ 0x6d }, std::byte{ 0x65 }, std::byte{ 0x22 }, std::byte{ 0x3a }, std::byte{ 0x22 }, std::byte{ 0x74 }, std::byte{ 0x68 },
+        std::byte{ 0x69 }, std::byte{ 0x73 }, std::byte{ 0x5f }, std::byte{ 0x67 }, std::byte{ 0x75 }, std::byte{ 0x79 }, std::byte{ 0x5f },
+        std::byte{ 0x61 }, std::byte{ 0x67 }, std::byte{ 0x61 }, std::byte{ 0x69 }, std::byte{ 0x6e }, std::byte{ 0x22 }, std::byte{ 0x7d },
+    };
+
+    auto decoded = couchbase::codec::json_transcoder::decode<profile>({ encoded_data, couchbase::codec::codec_flags::json_common_flags });
+    REQUIRE(decoded.username == "this_guy_again");
+    REQUIRE(decoded.full_name == "Albert Einstein");
+    REQUIRE(decoded.birth_year == 1879);
+
+    auto value =
+      couchbase::codec::json_transcoder::decode<tao::json::value>({ encoded_data, couchbase::codec::codec_flags::json_common_flags });
+    REQUIRE(value.at("username").get_string() == "this_guy_again");
+    REQUIRE(value.at("full_name").get_string() == "Albert Einstein");
+    REQUIRE(value.at("birth_year").get_unsigned() == 1879);
+}

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

@@ -17,7 +17,7 @@
 
 #include "test_helper.hxx"
 
-#include <couchbase/utils/json_streaming_lexer.hxx>
+#include "core/utils/json_streaming_lexer.hxx"
 
 #include <jsonsl.h>
 #include <ostream>

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

@@ -17,12 +17,13 @@
 
 #include "test_helper.hxx"
 
+#include "core/meta/version.hxx"
+#include "core/utils/join_strings.hxx"
+#include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include <couchbase/build_version.hxx>
-#include <couchbase/errors.hxx>
-#include <couchbase/meta/version.hxx>
-#include <couchbase/utils/join_strings.hxx>
-#include <couchbase/utils/json.hxx>
-#include <couchbase/utils/url_codec.hxx>
+
+#include <couchbase/error_codes.hxx>
 
 #include <tao/json.hpp>
 
@@ -34,8 +35,8 @@ TEST_CASE("unit: transformer to deduplicate JSON keys", "[unit]")
 
     CHECK_THROWS_WITH(tao::json::from_string(input), Contains("duplicate JSON object key \"answer\""));
 
-    auto result = couchbase::utils::json::parse(input);
-    INFO(couchbase::utils::json::generate(result))
+    auto result = couchbase::core::utils::json::parse(input);
+    INFO(couchbase::core::utils::json::generate(result))
     CHECK(result.is_object());
     CHECK(result.find("answer") != nullptr);
     CHECK(result["answer"].is_integer());
@@ -44,7 +45,7 @@ TEST_CASE("unit: transformer to deduplicate JSON keys", "[unit]")
 
 TEST_CASE("unit: string representation of the error codes", "[unit]")
 {
-    std::error_code rc = couchbase::error::common_errc::authentication_failure;
+    std::error_code rc = couchbase::errc::common::authentication_failure;
     CHECK(rc.category().name() == std::string("couchbase.common"));
     CHECK(rc.value() == 6);
     std::stringstream ss;
@@ -54,29 +55,29 @@ TEST_CASE("unit: string representation of the error codes", "[unit]")
 
 TEST_CASE("unit: url path escape", "[unit]")
 {
-    REQUIRE(couchbase::utils::string_codec::v2::path_escape("a/b") == "a%2Fb");
+    REQUIRE(couchbase::core::utils::string_codec::v2::path_escape("a/b") == "a%2Fb");
 }
 
 TEST_CASE("unit: join strings", "[unit]")
 {
     std::vector<std::string> field_specs{ "testkey:string" };
 
-    REQUIRE(couchbase::utils::join_strings(field_specs, ",") == "testkey:string");
+    REQUIRE(couchbase::core::utils::join_strings(field_specs, ",") == "testkey:string");
 
     field_specs.emplace_back("volume:double");
     field_specs.emplace_back("id:integer");
-    REQUIRE(couchbase::utils::join_strings(field_specs, ",") == "testkey:string,volume:double,id:integer");
+    REQUIRE(couchbase::core::utils::join_strings(field_specs, ",") == "testkey:string,volume:double,id:integer");
 }
 
 TEST_CASE("unit: join strings (fmt version)", "[unit]")
 {
     std::vector<std::string> field_specs{ "testkey:string" };
 
-    REQUIRE(couchbase::utils::join_strings_fmt("{}", field_specs, ",") == "testkey:string");
+    REQUIRE(couchbase::core::utils::join_strings_fmt("{}", field_specs, ",") == "testkey:string");
 
     field_specs.emplace_back("volume:double");
     field_specs.emplace_back("id:integer");
-    REQUIRE(couchbase::utils::join_strings_fmt("{}", field_specs, ",") == "testkey:string,volume:double,id:integer");
+    REQUIRE(couchbase::core::utils::join_strings_fmt("{}", field_specs, ",") == "testkey:string,volume:double,id:integer");
 }
 
 TEST_CASE("unit: user_agent string", "[unit]")
@@ -87,11 +88,11 @@ TEST_CASE("unit: user_agent string", "[unit]")
                                            COUCHBASE_CXX_CLIENT_VERSION_PATCH,
                                            COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT);
 
-    auto simple_user_agent = couchbase::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE");
+    auto simple_user_agent = couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE");
     REQUIRE(simple_user_agent == fmt::format(R"({{"a":"{}","i":"0xDEADBEEF/0xCAFEBEBE"}})", core_version));
     REQUIRE(simple_user_agent.size() == 53);
 
-    REQUIRE(couchbase::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", "couchnode/1.2.3; openssl/1.1.1l") ==
+    REQUIRE(couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", "couchnode/1.2.3; openssl/1.1.1l") ==
             fmt::format(R"({{"a":"{};couchnode/1.2.3; openssl/1.1.1l","i":"0xDEADBEEF/0xCAFEBEBE"}})", core_version));
 
     std::string long_extra = "01234567890abcdef01234567890abcdef"
@@ -104,24 +105,25 @@ TEST_CASE("unit: user_agent string", "[unit]")
                              "01234567890abcdef01234567890abcdef";
     REQUIRE(long_extra.size() == 272);
 
-    REQUIRE(couchbase::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", long_extra) ==
+    REQUIRE(couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", long_extra) ==
             fmt::format(R"({{"a":"{};{}","i":"0xDEADBEEF/0xCAFEBEBE"}})", core_version, long_extra));
 
-    auto trimmed_user_agent = couchbase::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", long_extra, 250);
+    auto trimmed_user_agent = couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", long_extra, 250);
     REQUIRE(trimmed_user_agent.size() == 250);
     REQUIRE(250 - simple_user_agent.size() == 197);
     REQUIRE(trimmed_user_agent == fmt::format(R"({{"a":"{};{}","i":"0xDEADBEEF/0xCAFEBEBE"}})", core_version, long_extra.substr(0, 196)));
 
     auto long_extra_with_non_printable_characters = long_extra.substr(0, 193) + "\n\n";
-    trimmed_user_agent = couchbase::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", long_extra_with_non_printable_characters, 250);
+    trimmed_user_agent =
+      couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", long_extra_with_non_printable_characters, 250);
     REQUIRE(trimmed_user_agent.size() == 249);
     REQUIRE(trimmed_user_agent ==
             fmt::format(R"({{"a":"{};{}","i":"0xDEADBEEF/0xCAFEBEBE"}})", core_version, long_extra.substr(0, 193) + "\\n"));
 
     auto long_and_weird_extra = "hello" + std::string(300, '\n');
-    trimmed_user_agent = couchbase::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", long_and_weird_extra, 250);
+    trimmed_user_agent = couchbase::core::meta::user_agent_for_mcbp("0xDEADBEEF", "0xCAFEBEBE", long_and_weird_extra, 250);
     REQUIRE(trimmed_user_agent == simple_user_agent);
 
-    REQUIRE(fmt::format("{}; client/0xDEADBEEF; session/0xCAFEBEBE; {}; hello world", core_version, couchbase::meta::os()) ==
-            couchbase::meta::user_agent_for_http("0xDEADBEEF", "0xCAFEBEBE", "hello\nworld"));
+    REQUIRE(fmt::format("{}; client/0xDEADBEEF; session/0xCAFEBEBE; {}; hello world", core_version, couchbase::core::meta::os()) ==
+            couchbase::core::meta::user_agent_for_http("0xDEADBEEF", "0xCAFEBEBE", "hello\nworld"));
 }

package/deps/couchbase-cxx-client/test/tools/tool_kv_loader.cxx

@@ -19,7 +19,7 @@
 #include "../utils/test_context.hxx"
 #include "../utils/uniq_id.hxx"
 
-#include <couchbase/logger/logger.hxx>
+#include "core/logger/logger.hxx"
 
 #include <spdlog/details/os.h>
 
@@ -60,11 +60,11 @@ dump_stats(asio::steady_timer& timer, std::chrono::system_clock::time_point star
 int
 main()
 {
-    couchbase::logger::create_console_logger();
+    couchbase::core::logger::create_console_logger();
     if (auto val = spdlog::details::os::getenv("TEST_LOG_LEVEL"); !val.empty()) {
-        couchbase::logger::set_log_levels(couchbase::logger::level_from_str(val));
+        couchbase::core::logger::set_log_levels(couchbase::core::logger::level_from_str(val));
     } else {
-        couchbase::logger::set_log_levels(couchbase::logger::level::info);
+        couchbase::core::logger::set_log_levels(couchbase::core::logger::level::info);
     }
 
     auto ctx = test::utils::test_context::load_from_environment();
@@ -88,8 +88,8 @@ main()
              ctx.connection_string,
              ctx.bucket);
 
-    auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
-    couchbase::cluster_credentials auth{};
+    auto connstr = couchbase::core::utils::parse_connection_string(ctx.connection_string);
+    couchbase::core::cluster_credentials auth{};
     if (!ctx.certificate_path.empty()) {
         auth.certificate_path = ctx.certificate_path;
         auth.key_path = ctx.key_path;
@@ -100,8 +100,8 @@ main()
 
     asio::io_context io(static_cast<int>(number_of_io_threads));
 
-    auto origin = couchbase::origin(auth, connstr);
-    auto cluster = couchbase::cluster::create(io);
+    auto origin = couchbase::core::origin(auth, connstr);
+    auto cluster = couchbase::core::cluster::create(io);
 
     std::vector<std::thread> io_pool{};
     io_pool.reserve(number_of_io_threads);
@@ -134,7 +134,7 @@ main()
              hit_chance_for_upsert,
              hit_chance_for_get);
 
-    const auto json_doc = couchbase::utils::to_binary(R"({
+    const auto json_doc = couchbase::core::utils::to_binary(R"({
   "type": "fake_profile",
   "random": 91,
   "random float": 16.439,
@@ -201,32 +201,33 @@ main()
             known_keys.emplace_back(current_key);
         }
 
-        couchbase::document_id id{ ctx.bucket, "_default", "_default", current_key };
+        couchbase::core::document_id id{ ctx.bucket, "_default", "_default", current_key };
         switch (opcode) {
             case operation::get: {
-                couchbase::operations::upsert_request req{ id, json_doc };
-                cluster->execute(req, [&total, &errors_mutex, &errors](const couchbase::operations::upsert_response& resp) {
+                couchbase::core::operations::upsert_request req{ id, json_doc };
+                cluster->execute(req, [&total, &errors_mutex, &errors](const couchbase::core::operations::upsert_response& resp) {
                     ++total;
-                    if (resp.ctx.ec) {
+                    if (resp.ctx.ec()) {
                         std::scoped_lock lock(errors_mutex);
-                        ++errors[resp.ctx.ec];
+                        ++errors[resp.ctx.ec()];
                     }
                 });
             } break;
             case operation::upsert: {
-                couchbase::operations::get_request req{ id };
-                cluster->execute(req, [&total, &errors_mutex, &errors](const couchbase::operations::get_response&& resp) {
+                couchbase::core::operations::get_request req{ id };
+                cluster->execute(req, [&total, &errors_mutex, &errors](const couchbase::core::operations::get_response&& resp) {
                     ++total;
-                    if (resp.ctx.ec) {
+                    if (resp.ctx.ec()) {
                         std::scoped_lock lock(errors_mutex);
-                        ++errors[resp.ctx.ec];
+                        ++errors[resp.ctx.ec()];
                     }
                 });
             } break;
         }
         if (send_queries) {
-            couchbase::operations::query_request req{ fmt::format("SELECT COUNT(*) FROM `{}` WHERE type = \"fake_profile\"", ctx.bucket) };
-            cluster->execute(req, [&total, &errors_mutex, &errors](const couchbase::operations::query_response&& resp) {
+            couchbase::core::operations::query_request req{ fmt::format("SELECT COUNT(*) FROM `{}` WHERE type = \"fake_profile\"",
+                                                                        ctx.bucket) };
+            cluster->execute(req, [&total, &errors_mutex, &errors](const couchbase::core::operations::query_response&& resp) {
                 ++total;
                 if (resp.ctx.ec) {
                     std::scoped_lock lock(errors_mutex);
@@ -244,13 +245,16 @@ main()
     fmt::print("total time: {}s ({}ms)\n",
                std::chrono::duration_cast<std::chrono::seconds>(total_time).count(),
                std::chrono::duration_cast<std::chrono::milliseconds>(total_time).count());
-    auto diff = std::chrono::duration_cast<std::chrono::seconds>(total_time).count();
-    fmt::print("total rate: {} ops/s\n", total / static_cast<std::uint64_t>(diff));
-    std::scoped_lock lock(errors_mutex);
-    if (!errors.empty()) {
-        fmt::print("error stats:\n");
-        for (auto [ec, count] : errors) {
-            fmt::print("    {} ({}): {}\n", ec.message(), ec.value(), count);
+    if (auto diff = std::chrono::duration_cast<std::chrono::seconds>(total_time).count(); diff > 0) {
+        fmt::print("total rate: {} ops/s\n", total / static_cast<std::uint64_t>(diff));
+    }
+    {
+        std::scoped_lock lock(errors_mutex);
+        if (!errors.empty()) {
+            fmt::print("error stats:\n");
+            for (auto [ec, count] : errors) {
+                fmt::print("    {}: {}\n", ec.message(), count);
+            }
         }
     }
 

package/deps/couchbase-cxx-client/test/utils/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_library(
   test_utils OBJECT
+  binary.cxx
   integration_shortcuts.cxx
   integration_test_guard.cxx
   logger.cxx

package/deps/couchbase-cxx-client/test/utils/binary.cxx

@@ -0,0 +1,27 @@
+/* -*- 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 "binary.hxx"
+
+namespace test::utils
+{
+[[nodiscard]] std::string
+to_string(const std::vector<std::byte>& input)
+{
+    return { reinterpret_cast<const char*>(input.data()), input.size() };
+}
+} // namespace test::utils

package/deps/couchbase-cxx-client/test/utils/binary.hxx

@@ -0,0 +1,27 @@
+/* -*- 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.
+ */
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace test::utils
+{
+[[nodiscard]] std::string
+to_string(const std::vector<std::byte>& input);
+}