couchbase 3.4.1 → 3.4.3

data/ext/couchbase/test/test_unit_config_profiles.cxx

@@ -18,7 +18,7 @@
 #include "test_helper.hxx"
 
 #include "core/cluster_options.hxx"
-#include "core/config_profile.hxx"
+#include "core/config_profiles.hxx"
 #include <stdexcept>
 
 class test_profile : public couchbase::core::config_profile
@@ -52,14 +52,17 @@ TEST_CASE("unit: can apply wan_development profile", "[unit]")
     // for details and latest info on expectations.
     couchbase::core::cluster_options opts{};
     opts.apply_profile("wan_development");
-    CHECK(opts.key_value_timeout.count() == 20000);
-    CHECK(opts.key_value_durable_timeout.count() == 20000);
-    CHECK(opts.connect_timeout.count() == 20000);
-    CHECK(opts.view_timeout.count() == 120000);
-    CHECK(opts.query_timeout.count() == 120000);
-    CHECK(opts.analytics_timeout.count() == 120000);
-    CHECK(opts.search_timeout.count() == 120000);
-    CHECK(opts.management_timeout.count() == 120000);
+    CHECK(opts.key_value_timeout.count() == 20'000);
+    CHECK(opts.key_value_durable_timeout.count() == 20'000);
+    CHECK(opts.connect_timeout.count() == 20'000);
+    CHECK(opts.view_timeout.count() == 120'000);
+    CHECK(opts.query_timeout.count() == 120'000);
+    CHECK(opts.analytics_timeout.count() == 120'000);
+    CHECK(opts.search_timeout.count() == 120'000);
+    CHECK(opts.management_timeout.count() == 120'000);
+    CHECK(opts.bootstrap_timeout.count() == 120'000);
+    CHECK(opts.resolve_timeout.count() == 20'000);
+    CHECK(opts.dns_config.timeout().count() == 20'000);
 }
 
 TEST_CASE("unit: all other options remain unchanged", "[unit]")
@@ -71,11 +74,9 @@ TEST_CASE("unit: all other options remain unchanged", "[unit]")
     // we'd expect default_opts to be equal to opts:
     CHECK(opts.tracer == default_opts.tracer);
     CHECK(opts.meter == default_opts.meter);
-    CHECK(opts.bootstrap_timeout == default_opts.bootstrap_timeout);
     CHECK(opts.config_idle_redial_timeout == default_opts.config_idle_redial_timeout);
     CHECK(opts.config_poll_floor == default_opts.config_poll_floor);
     CHECK(opts.config_poll_interval == default_opts.config_poll_interval);
-    CHECK(opts.dns_srv_timeout == default_opts.dns_srv_timeout);
     CHECK(opts.enable_clustermap_notification == opts.enable_clustermap_notification);
     CHECK(opts.enable_compression == default_opts.enable_compression);
     CHECK(opts.enable_dns_srv == default_opts.enable_dns_srv);
@@ -88,7 +89,6 @@ TEST_CASE("unit: all other options remain unchanged", "[unit]")
     CHECK(opts.idle_http_connection_timeout == default_opts.idle_http_connection_timeout);
     CHECK(opts.max_http_connections == default_opts.max_http_connections);
     CHECK(opts.network == default_opts.network);
-    CHECK(opts.resolve_timeout == default_opts.resolve_timeout);
     CHECK(opts.show_queries == default_opts.show_queries);
     CHECK(opts.tcp_keep_alive_interval == default_opts.tcp_keep_alive_interval);
     CHECK(opts.tls_verify == default_opts.tls_verify);
@@ -129,4 +129,4 @@ TEST_CASE("unit: can have profile with constructor args", "[unit]")
                                                                                std::string("something_extra"));
     opts.apply_profile("test_with_args");
     CHECK(opts.user_agent_extra == "something_extra");
-}
+}

data/ext/couchbase/test/test_unit_connection_string.cxx

@@ -52,6 +52,8 @@ TEST_CASE("unit: connection string", "[unit]")
         CHECK(couchbase::core::utils::parse_connection_string("http://127.0.0.1").scheme == "http");
         CHECK(couchbase::core::utils::parse_connection_string("couchbase://").scheme == "couchbase");
         CHECK(couchbase::core::utils::parse_connection_string("my+scheme://").scheme == "my+scheme");
+        CHECK(couchbase::core::utils::parse_connection_string("127.0.0.1").scheme == "couchbase");
+        CHECK(couchbase::core::utils::parse_connection_string("127.0.0.1:8091").scheme == "couchbase");
 
         SECTION("default bootstrap mode")
         {
@@ -155,6 +157,13 @@ TEST_CASE("unit: connection string", "[unit]")
                       couchbase::core::utils::connection_string::address_type::dns,
                       couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
                   });
+            CHECK(couchbase::core::utils::parse_connection_string("1.2.3.4").bootstrap_nodes ==
+                  std::vector<couchbase::core::utils::connection_string::node>{
+                    { "1.2.3.4",
+                      0,
+                      couchbase::core::utils::connection_string::address_type::ipv4,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                  });
         }
 
         SECTION("multiple nodes")
@@ -207,6 +216,17 @@ TEST_CASE("unit: connection string", "[unit]")
                       couchbase::core::utils::connection_string::address_type::ipv4,
                       couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
                   });
+            CHECK(couchbase::core::utils::parse_connection_string("1.2.3.4,4.3.2.1").bootstrap_nodes ==
+                  std::vector<couchbase::core::utils::connection_string::node>{
+                    { "1.2.3.4",
+                      0,
+                      couchbase::core::utils::connection_string::address_type::ipv4,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                    { "4.3.2.1",
+                      0,
+                      couchbase::core::utils::connection_string::address_type::ipv4,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                  });
         }
 
         SECTION("custom ports")
@@ -259,6 +279,21 @@ TEST_CASE("unit: connection string", "[unit]")
                       couchbase::core::utils::connection_string::address_type::ipv4,
                       couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
                   });
+            CHECK(couchbase::core::utils::parse_connection_string("example.com:123,[::1]:456;127.0.0.1:789").bootstrap_nodes ==
+                  std::vector<couchbase::core::utils::connection_string::node>{
+                    { "example.com",
+                      123,
+                      couchbase::core::utils::connection_string::address_type::dns,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                    { "::1",
+                      456,
+                      couchbase::core::utils::connection_string::address_type::ipv6,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                    { "127.0.0.1",
+                      789,
+                      couchbase::core::utils::connection_string::address_type::ipv4,
+                      couchbase::core::utils::connection_string::bootstrap_mode::unspecified },
+                  });
         }
 
         SECTION("custom bootstrap mode")

data/ext/couchbase/test/test_unit_json_transcoder.cxx

@@ -17,10 +17,14 @@
 
 #include "test_helper.hxx"
 
+#include <catch2/catch_approx.hpp>
+
 #include <couchbase/codec/default_json_transcoder.hxx>
 
 #include <tao/json.hpp>
 
+using Catch::Approx;
+
 TEST_CASE("unit: default_json_transcoder encodes primitives", "[unit]")
 {
     {

data/ext/couchbase/test/test_unit_search.cxx

@@ -0,0 +1,427 @@
+/* -*- 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.hxx"
+
+#include "core/impl/encoded_search_query.hxx"
+
+#include <couchbase/boolean_field_query.hxx>
+#include <couchbase/boolean_query.hxx>
+#include <couchbase/conjunction_query.hxx>
+#include <couchbase/date_range_query.hxx>
+#include <couchbase/disjunction_query.hxx>
+#include <couchbase/geo_bounding_box_query.hxx>
+#include <couchbase/geo_distance_query.hxx>
+#include <couchbase/geo_polygon_query.hxx>
+#include <couchbase/match_phrase_query.hxx>
+#include <couchbase/match_query.hxx>
+#include <couchbase/numeric_range_query.hxx>
+#include <couchbase/phrase_query.hxx>
+#include <couchbase/prefix_query.hxx>
+#include <couchbase/query_string_query.hxx>
+#include <couchbase/regexp_query.hxx>
+#include <couchbase/term_query.hxx>
+#include <couchbase/term_range_query.hxx>
+#include <couchbase/wildcard_query.hxx>
+
+#include <tao/json.hpp>
+
+using namespace tao::json::literals;
+
+TEST_CASE("unit: query string search query", "[unit]")
+{
+    {
+        // clang-format off
+//! [search-query-string-boosting]
+couchbase::query_string_query query(R"(description:pool name:pool^5)");
+//! [search-query-string-boosting]
+        // clang-format on
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == "{\"query\":\"description:pool name:pool^5\"}"_json);
+    }
+    {
+        // clang-format off
+//! [search-query-string-date-range]
+couchbase::query_string_query query(R"(created:>"2016-09-21")");
+//! [search-query-string-date-range]
+        // clang-format on
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == "{\"query\":\"created:>\\\"2016-09-21\\\"\"}"_json);
+    }
+
+    {
+        // clang-format off
+//! [search-query-string-numeric-range]
+couchbase::query_string_query query(R"(reviews.ratings.Cleanliness:>4)");
+//! [search-query-string-numeric-range]
+        // clang-format on
+        query.boost(1.42);
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == "{\"boost\":1.42,\"query\":\"reviews.ratings.Cleanliness:>4\"}"_json);
+    }
+}
+
+TEST_CASE("unit: match search query", "[unit]")
+{
+    {
+        // clang-format off
+//! [search-match]
+auto query = couchbase::match_query("location hostel")
+              .field("reviews.content")
+              .analyzer("standard")
+              .fuzziness(2)
+              .prefix_length(4)
+              .match_operator(couchbase::match_operator::logical_and);
+//! [search-match]
+        // clang-format on
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == R"(
+{"analyzer":"standard","field":"reviews.content","fuzziness":2,"match":"location hostel","operator":"and","prefix_length":4}
+)"_json);
+    }
+}
+
+TEST_CASE("unit: conjunction search query", "[unit]")
+{
+    // clang-format off
+//! [search-conjunction]
+auto query = couchbase::conjunction_query{
+  couchbase::match_query("location hostel").field("reviews.content"),
+  couchbase::boolean_field_query(true).field("free_breakfast")
+};
+//! [search-conjunction]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"conjuncts":[
+    {"field":"reviews.content","match":"location hostel"},
+    {"bool":true,"field":"free_breakfast"}
+]}
+)"_json);
+}
+
+TEST_CASE("unit: disjunction search query", "[unit]")
+{
+    // clang-format off
+//! [search-disjunction]
+auto query = couchbase::disjunction_query{
+  couchbase::match_query("location hostel").field("reviews.content"),
+  couchbase::boolean_field_query(true).field("free_breakfast")
+};
+//! [search-disjunction]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"disjuncts":[
+    {"field":"reviews.content","match":"location hostel"},
+    {"bool":true,"field":"free_breakfast"}
+]}
+)"_json);
+}
+
+TEST_CASE("unit: boolean search query", "[unit]")
+{
+    // clang-format off
+//! [search-boolean]
+couchbase::boolean_query query;
+query.must(
+  couchbase::match_query("hostel room").field("reviews.content"),
+  couchbase::boolean_field_query(true).field("free_breakfast"));
+query.should(
+  couchbase::numeric_range_query().field("reviews.ratings.Overall").min(4),
+  couchbase::numeric_range_query().field("reviews.ratings.Service").min(5));
+query.must_not(
+  couchbase::match_query("Padfield Gilingham").field("city"));
+//! [search-boolean]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"must":     {"conjuncts":[{"field":"reviews.content","match":"hostel room"},{"bool":true,"field":"free_breakfast"}]},
+ "must_not": {"disjuncts":[{"field":"city","match":"Padfield Gilingham"}]},
+ "should":   {"disjuncts":[{"field":"reviews.ratings.Overall","min":4},{"field":"reviews.ratings.Service","min":5}]}}
+)"_json);
+}
+
+TEST_CASE("unit: term search query", "[unit]")
+{
+    // clang-format off
+//! [search-term]
+auto query = couchbase::term_query("locate").field("reviews.content");
+//! [search-term]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"term": "locate", "field": "reviews.content"}
+)"_json);
+}
+
+TEST_CASE("unit: match phrase search query", "[unit]")
+{
+    // clang-format off
+//! [search-match-phrase]
+auto query = couchbase::match_phrase_query("nice view").field("reviews.content");
+//! [search-match-phrase]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"match_phrase": "nice view", "field": "reviews.content"}
+)"_json);
+}
+
+TEST_CASE("unit: phrase search query", "[unit]")
+{
+    // clang-format off
+//! [search-phrase]
+auto query = couchbase::phrase_query({"nice", "view"}).field("reviews.content");
+//! [search-phrase]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"terms": ["nice", "view"], "field": "reviews.content"}
+)"_json);
+}
+
+TEST_CASE("unit: prefix search query", "[unit]")
+{
+    // clang-format off
+//! [search-prefix]
+auto query = couchbase::prefix_query("inter").field("reviews.content");
+//! [search-prefix]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"prefix": "inter", "field": "reviews.content"}
+)"_json);
+}
+
+TEST_CASE("unit: regexp search query", "[unit]")
+{
+    // clang-format off
+//! [search-regexp]
+auto query = couchbase::regexp_query("inter.+").field("reviews.content");
+//! [search-regexp]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"regexp": "inter.+", "field": "reviews.content"}
+)"_json);
+}
+
+TEST_CASE("unit: wildcard search query", "[unit]")
+{
+    // clang-format off
+//! [search-wildcard]
+auto query = couchbase::wildcard_query("inter*").field("reviews.content");
+//! [search-wildcard]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"wildcard": "inter*", "field": "reviews.content"}
+)"_json);
+}
+
+TEST_CASE("unit: numeric range search query", "[unit]")
+{
+    // clang-format off
+//! [search-numeric-range]
+auto query = couchbase::numeric_range_query()
+               .field("id")
+               .min(100,  /* inclusive= */ false)
+               .max(1000, /* inclusive= */ false);
+//! [search-numeric-range]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"min": 100, "inclusive_min": false, "max": 1000, "inclusive_max": false, "field": "id"}
+)"_json);
+}
+
+TEST_CASE("unit: date range search query", "[unit]")
+{
+    {
+        // clang-format off
+//! [search-date-range]
+auto query = couchbase::date_range_query()
+               .field("review_date")
+               .start("2001-10-09T10:20:30-08:00", /* inclusive= */ false)
+               .end("2016-10-31",                  /* inclusive= */ false);
+//! [search-date-range]
+        // clang-format on
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == R"(
+{"start": "2001-10-09T10:20:30-08:00", "inclusive_start": false, "end": "2016-10-31", "inclusive_end": false, "field": "review_date"}
+)"_json);
+    }
+
+    {
+        // clang-format off
+//! [search-date-range-tm]
+std::tm start_tm{};
+start_tm.tm_year = 2001 - 1900;
+start_tm.tm_mon = 9;
+start_tm.tm_mday = 9;
+start_tm.tm_hour = 10;
+start_tm.tm_min = 20;
+start_tm.tm_sec = 30;
+
+std::tm end_tm{};
+end_tm.tm_year = 2001 - 1900;
+end_tm.tm_mon = 9;
+end_tm.tm_mday = 31;
+
+auto query = couchbase::date_range_query()
+               .field("review_date")
+               .start(start_tm)
+               .end(end_tm);
+// equivalent of {"field":"review_date","start":"2001-10-09T10:20:30+0000","end":"2001-10-31T00:00:00+0000"}
+//! [search-date-range-tm]
+        // clang-format on
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == R"(
+{"end":"2001-10-31T00:00:00+0000","field":"review_date","start":"2001-10-09T10:20:30+0000"}
+)"_json);
+    }
+}
+
+TEST_CASE("unit: term range search query", "[unit]")
+{
+    // clang-format off
+//! [search-term-range]
+auto query = couchbase::term_range_query()
+                .field("desc")
+                .min("foo",  /* inclusive= */ false)
+                .max("foof", /* inclusive= */ false);
+//! [search-term-range]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{"min": "foo", "inclusive_min": false, "max": "foof", "inclusive_max": false, "field": "desc"}
+)"_json);
+}
+
+TEST_CASE("unit: special search query", "[unit]")
+{
+    {
+        auto query = couchbase::match_none_query();
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == R"({"match_none": {}})"_json);
+    }
+    {
+        auto query = couchbase::match_all_query();
+        const auto encoded = query.encode();
+        REQUIRE_FALSE(encoded.ec);
+        REQUIRE(encoded.query == R"({"match_all": {}})"_json);
+    }
+}
+
+TEST_CASE("unit: geo distance search query", "[unit]")
+{
+    // clang-format off
+//! [search-geo-distance]
+auto query = couchbase::geo_distance_query(53.482358, -2.235143, "100mi")
+               .field("geo");
+//! [search-geo-distance]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{
+  "location": {
+    "lon": -2.235143,
+    "lat": 53.482358
+   },
+    "distance": "100mi",
+    "field": "geo"
+}
+)"_json);
+}
+
+TEST_CASE("unit: geo bounding box search query", "[unit]")
+{
+    // clang-format off
+//! [search-geo-bounding-box]
+auto query = couchbase::geo_bounding_box_query(
+                  couchbase::geo_point{53.482358, -2.235143},
+                  couchbase::geo_point{40.991862, 28.955043}
+                ).field("geo");
+//! [search-geo-bounding-box]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{
+  "top_left": {
+    "lon": -2.235143,
+    "lat": 53.482358
+   },
+  "bottom_right": {
+    "lon": 28.955043,
+    "lat": 40.991862
+   },
+    "field": "geo"
+}
+)"_json);
+}
+
+TEST_CASE("unit: geo polygon search query", "[unit]")
+{
+    // clang-format off
+//! [search-geo-polygon]
+auto query = couchbase::geo_polygon_query({
+                couchbase::geo_point{ 37.79393211306212, -122.44234633404847 },
+                couchbase::geo_point{ 37.77995881733997, -122.43977141339417 },
+                couchbase::geo_point{ 37.788031092020155, -122.42925715405579 },
+                couchbase::geo_point{ 37.79026946582319, -122.41149020154114 },
+                couchbase::geo_point{ 37.79571192027403, -122.40735054016113 },
+                couchbase::geo_point{ 37.79393211306212, -122.44234633404847 },
+             }).field("geo");
+//! [search-geo-polygon]
+    // clang-format on
+    const auto encoded = query.encode();
+    REQUIRE_FALSE(encoded.ec);
+    REQUIRE(encoded.query == R"(
+{
+    "field": "geo",
+    "polygon_points": [
+      {"lat": 37.79393211306212, "lon": -122.44234633404847},
+      {"lat": 37.77995881733997, "lon": -122.43977141339417},
+      {"lat": 37.788031092020155, "lon": -122.42925715405579},
+      {"lat": 37.79026946582319, "lon": -122.41149020154114},
+      {"lat": 37.79571192027403, "lon": -122.40735054016113},
+      {"lat": 37.79393211306212, "lon": -122.44234633404847}
+    ]
+}
+)"_json);
+}

data/ext/couchbase/test/test_unit_transaction_utils.cxx

@@ -26,6 +26,15 @@
 #include <limits>
 #include <thread>
 
+#if defined(__GNUC__)
+#if __GNUC__ <= 10
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+#if __GNUC__ < 9
+#pragma GCC diagnostic ignored "-Wuseless-cast"
+#endif
+#endif
+
 using namespace couchbase::core::transactions;
 using namespace std;
 
@@ -315,4 +324,4 @@ TEST_CASE("transaction_get_result: can convert core transaction_get_result to pu
         auto final_public_res = core_res.to_public_result();
         REQUIRE(final_public_res.cas().empty());
     }
-}
+}

data/ext/couchbase/test/test_unit_utils.cxx

@@ -17,6 +17,10 @@
 
 #include "test_helper.hxx"
 
+#include <catch2/matchers/catch_matchers.hpp>
+#include <catch2/matchers/catch_matchers_exception.hpp>
+#include <catch2/matchers/catch_matchers_string.hpp>
+
 #include "core/meta/version.hxx"
 #include "core/platform/base64.h"
 #include "core/utils/join_strings.hxx"
@@ -32,14 +36,14 @@
 
 TEST_CASE("unit: transformer to deduplicate JSON keys", "[unit]")
 {
-    using Catch::Contains;
+    using Catch::Matchers::ContainsSubstring;
 
     std::string input{ R"({"answer":"wrong","answer":42})" };
 
-    CHECK_THROWS_WITH(tao::json::from_string(input), Contains("duplicate JSON object key \"answer\""));
+    CHECK_THROWS_WITH(tao::json::from_string(input), ContainsSubstring("duplicate JSON object key \"answer\""));
 
     auto result = couchbase::core::utils::json::parse(input);
-    INFO(couchbase::core::utils::json::generate(result))
+    INFO(couchbase::core::utils::json::generate(result));
     CHECK(result.is_object());
     CHECK(result.find("answer") != nullptr);
     CHECK(result["answer"].is_integer());
@@ -96,7 +100,7 @@ TEST_CASE("unit: user_agent string", "[unit]")
 
     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() == 66);
+    REQUIRE(simple_user_agent.size() == 53 + os_version.size());
 
     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));