couchbase 3.0.0.alpha.5 → 3.0.3

data/ext/test/test_helper_native.hxx

@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 "test_helper.hxx"
+
+#include <asio/version.hpp>
+
+#include <spdlog/cfg/env.h>
+#include <spdlog/spdlog.h>
+
+#include <http_parser.h>
+
+#include <snappy.h>
+
+#include <version.hxx>
+
+#include <cluster.hxx>
+#include <operations.hxx>
+
+#include <io/dns_client.hxx>
+#include <utils/connection_string.hxx>
+
+void
+native_init_logger()
+{
+    static bool initialized = false;
+
+    if (!initialized) {
+        spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v");
+
+        auto env_val = spdlog::details::os::getenv("COUCHBASE_BACKEND_LOG_LEVEL");
+        if (env_val.empty()) {
+            spdlog::set_level(spdlog::level::warn);
+        } else {
+            spdlog::cfg::helpers::load_levels(env_val);
+        }
+
+        initialized = true;
+    }
+}

data/ext/test/test_helper_ruby.hxx

@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 "test_helper.hxx"
+#include <optional>
+
+#include <ruby.h>
+
+extern "C" {
+void
+rb_encdb_declare(const char* name);
+int
+rb_encdb_alias(const char* alias, const char* orig);
+}
+
+struct ruby_context {
+    ruby_context()
+    {
+        ruby_init();
+        ruby_init_loadpath();
+
+        rb_encdb_declare("ASCII-8BIT");
+        rb_encdb_declare("US-ASCII");
+        rb_encdb_declare("UTF-8");
+        rb_encdb_alias("BINARY", "ASCII-8BIT");
+        rb_encdb_alias("ASCII", "US-ASCII");
+        rb_require("rubygems");
+        rb_require("json");
+        rb_require(LIBCOUCHBASE_EXT_PATH);
+    }
+
+    ~ruby_context()
+    {
+        ruby_cleanup(0);
+    }
+
+    std::optional<std::string> eval_script(test_context& ctx, const std::string& input)
+    {
+        int status = 0;
+        std::string script = input;
+        script = std::regex_replace(script, std::regex("CONNECTION_STRING"), '"' + ctx.connection_string + '"');
+        script = std::regex_replace(script, std::regex("USERNAME"), '"' + ctx.username + '"');
+        script = std::regex_replace(script, std::regex("PASSWORD"), '"' + ctx.password + '"');
+        script = std::regex_replace(script, std::regex("BUCKET"), '"' + ctx.bucket + '"');
+        rb_eval_string_protect(script.c_str(), &status);
+        if (status != 0) {
+            VALUE rbError = rb_funcall(rb_gv_get("$!"), rb_intern("message"), 0);
+            return std::string(StringValuePtr(rbError));
+        }
+        return {};
+    }
+};
+
+#define TEST_PREAMBLE_RUBY                                                                                                                 \
+    RUBY_INIT_STACK;                                                                                                                       \
+    ruby_context ruby{};

data/ext/test/test_native_binary_operations.cxx

@@ -0,0 +1,186 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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_native.hxx"
+
+std::string
+uniq_id(const std::string& prefix)
+{
+    return fmt::format("{}_{}", prefix, std::chrono::steady_clock::now().time_since_epoch().count());
+}
+
+TEST_CASE("native: append", "[native]")
+{
+    auto ctx = test_context::load_from_environment();
+    native_init_logger();
+
+    auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
+    couchbase::cluster_credentials auth{};
+    auth.username = ctx.username;
+    auth.password = ctx.password;
+
+    asio::io_context io;
+
+    couchbase::cluster cluster(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(couchbase::origin(auth, connstr), [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        cluster.open_bucket(ctx.bucket, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    couchbase::document_id id{ ctx.bucket, "_default._default", uniq_id("foo") };
+    {
+        couchbase::operations::upsert_request req{ id, "world" };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::upsert_response&& resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ctx.ec.message());
+        REQUIRE_FALSE(resp.ctx.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("seqno=" << resp.token.sequence_number);
+        REQUIRE(resp.token.sequence_number != 0);
+    }
+    {
+        couchbase::operations::append_request req{ id, "!" };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::append_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::append_response&& resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ctx.ec.message());
+        REQUIRE_FALSE(resp.ctx.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("seqno=" << resp.token.sequence_number);
+        REQUIRE(resp.token.sequence_number != 0);
+    }
+    {
+        couchbase::operations::get_request req{ id };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::get_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::get_response&& resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ctx.ec.message());
+        REQUIRE_FALSE(resp.ctx.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("value=" << resp.value);
+        REQUIRE(resp.value == "world!");
+    }
+    {
+        auto barrier = std::make_shared<std::promise<void>>();
+        auto f = barrier->get_future();
+        cluster.close([barrier]() { barrier->set_value(); });
+        f.get();
+    }
+
+    io_thread.join();
+}
+
+TEST_CASE("native: prepend", "[native]")
+{
+    auto ctx = test_context::load_from_environment();
+    native_init_logger();
+
+    auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
+    couchbase::cluster_credentials auth{};
+    auth.username = ctx.username;
+    auth.password = ctx.password;
+
+    asio::io_context io;
+
+    couchbase::cluster cluster(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(couchbase::origin(auth, connstr), [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        cluster.open_bucket(ctx.bucket, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    couchbase::document_id id{ ctx.bucket, "_default._default", uniq_id("foo") };
+    {
+        couchbase::operations::upsert_request req{ id, "world" };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::upsert_response&& resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ctx.ec.message());
+        REQUIRE_FALSE(resp.ctx.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("seqno=" << resp.token.sequence_number);
+        REQUIRE(resp.token.sequence_number != 0);
+    }
+    {
+        couchbase::operations::prepend_request req{ id, "Hello, " };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::prepend_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::prepend_response&& resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ctx.ec.message());
+        REQUIRE_FALSE(resp.ctx.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("seqno=" << resp.token.sequence_number);
+        REQUIRE(resp.token.sequence_number != 0);
+    }
+    {
+        couchbase::operations::get_request req{ id };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::get_response>>();
+        auto f = barrier->get_future();
+        cluster.execute(req, [barrier](couchbase::operations::get_response&& resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ctx.ec.message());
+        REQUIRE_FALSE(resp.ctx.ec);
+        INFO("rc=" << resp.cas);
+        REQUIRE(resp.cas != 0);
+        INFO("value=" << resp.value);
+        REQUIRE(resp.value == "Hello, world");
+    }
+    {
+        auto barrier = std::make_shared<std::promise<void>>();
+        auto f = barrier->get_future();
+        cluster.close([barrier]() { barrier->set_value(); });
+        f.get();
+    }
+
+    io_thread.join();
+}

data/ext/test/test_native_diagnostics.cxx

@@ -0,0 +1,436 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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_native.hxx"
+
+#include <diagnostics.hxx>
+
+using namespace std::literals::chrono_literals;
+
+TEST_CASE("native: serializing diagnostics report", "[native]")
+{
+    couchbase::diag::diagnostics_result res{
+        "0xdeadbeef",
+        "ruby/1.0.0",
+        {
+          {
+            {
+              couchbase::service_type::search,
+              {
+                {
+                  couchbase::service_type::search,
+                  "0x1415F11",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:8094",
+                  "127.0.0.1:54669",
+                  couchbase::diag::endpoint_state::connecting,
+                  std::nullopt,
+                  "RECONNECTING, backoff for 4096ms from Fri Sep  1 00:03:44 PDT 2017",
+                },
+              },
+            },
+            {
+              couchbase::service_type::kv,
+              {
+                {
+                  couchbase::service_type::kv,
+                  "0x1415F12",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:11210",
+                  "127.0.0.1:54670",
+                  couchbase::diag::endpoint_state::connected,
+                  "bucketname",
+                },
+              },
+            },
+            {
+              couchbase::service_type::query,
+              {
+                {
+                  couchbase::service_type::query,
+                  "0x1415F13",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:8093",
+                  "127.0.0.1:54671",
+                  couchbase::diag::endpoint_state::connected,
+                },
+                {
+                  couchbase::service_type::query,
+                  "0x1415F14",
+                  1182000us,
+                  "centos7-lx2.home.ingenthron.org:8095",
+                  "127.0.0.1:54682",
+                  couchbase::diag::endpoint_state::disconnected,
+                },
+              },
+            },
+            {
+              couchbase::service_type::analytics,
+              {
+                {
+                  couchbase::service_type::analytics,
+                  "0x1415F15",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:8095",
+                  "127.0.0.1:54675",
+                  couchbase::diag::endpoint_state::connected,
+                },
+              },
+            },
+            {
+              couchbase::service_type::views,
+              {
+                {
+                  couchbase::service_type::views,
+                  "0x1415F16",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:8092",
+                  "127.0.0.1:54672",
+                  couchbase::diag::endpoint_state::connected,
+                },
+              },
+            },
+          },
+        },
+    };
+
+    auto expected = tao::json::from_string(R"(
+{
+  "version": 2,
+  "id": "0xdeadbeef",
+  "sdk": "ruby/1.0.0",
+  "services": {
+    "kv": [
+      {
+        "id": "0x1415F12",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:11210",
+        "local": "127.0.0.1:54670",
+        "state": "connected",
+        "namespace": "bucketname"
+      }
+    ],
+    "search": [
+      {
+        "id": "0x1415F11",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:8094",
+        "local": "127.0.0.1:54669",
+        "state": "connecting",
+        "details": "RECONNECTING, backoff for 4096ms from Fri Sep  1 00:03:44 PDT 2017"
+      }
+    ],
+    "query": [
+      {
+        "id": "0x1415F13",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:8093",
+        "local": "127.0.0.1:54671",
+        "state": "connected"
+      },
+      {
+        "id": "0x1415F14",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx2.home.ingenthron.org:8095",
+        "local": "127.0.0.1:54682",
+        "state": "disconnected"
+      }
+    ],
+    "analytics": [
+      {
+        "id": "0x1415F15",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:8095",
+        "local": "127.0.0.1:54675",
+        "state": "connected"
+      }
+    ],
+    "views": [
+      {
+        "id": "0x1415F16",
+        "last_activity_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:8092",
+        "local": "127.0.0.1:54672",
+        "state": "connected"
+      }
+    ]
+  }
+}
+)");
+    auto report = tao::json::value(res);
+    REQUIRE(report == expected);
+}
+
+TEST_CASE("native: serializing ping report", "[native]")
+{
+    auto ctx = test_context::load_from_environment();
+    native_init_logger();
+
+    couchbase::diag::ping_result res{
+        "0xdeadbeef",
+        "ruby/1.0.0",
+        {
+          {
+            {
+              couchbase::service_type::search,
+              {
+                {
+                  couchbase::service_type::search,
+                  "0x1415F11",
+                  877909us,
+                  "centos7-lx1.home.ingenthron.org:8094",
+                  "127.0.0.1:54669",
+                  couchbase::diag::ping_state::ok,
+                },
+              },
+            },
+            {
+              couchbase::service_type::kv,
+              {
+                {
+                  couchbase::service_type::kv,
+                  "0x1415F12",
+                  1182000us,
+                  "centos7-lx1.home.ingenthron.org:11210",
+                  "127.0.0.1:54670",
+                  couchbase::diag::ping_state::ok,
+                  "bucketname",
+                },
+              },
+            },
+            {
+              couchbase::service_type::query,
+              {
+                {
+                  couchbase::service_type::query,
+                  "0x1415F14",
+                  2213us,
+                  "centos7-lx2.home.ingenthron.org:8095",
+                  "127.0.0.1:54682",
+                  couchbase::diag::ping_state::timeout,
+                },
+              },
+            },
+            {
+              couchbase::service_type::analytics,
+              {
+                {
+                  couchbase::service_type::analytics,
+                  "0x1415F15",
+                  2213us,
+                  "centos7-lx1.home.ingenthron.org:8095",
+                  "127.0.0.1:54675",
+                  couchbase::diag::ping_state::error,
+                  std::nullopt,
+                  "endpoint returned HTTP code 500!",
+                },
+              },
+            },
+            {
+              couchbase::service_type::views,
+              {
+                {
+                  couchbase::service_type::views,
+                  "0x1415F16",
+                  45585us,
+                  "centos7-lx1.home.ingenthron.org:8092",
+                  "127.0.0.1:54672",
+                  couchbase::diag::ping_state::ok,
+                },
+              },
+            },
+          },
+        },
+    };
+
+    auto expected = tao::json::from_string(R"(
+{
+  "version": 2,
+  "id": "0xdeadbeef",
+  "config_rev": 53,
+  "sdk": "ruby/1.0.0",
+  "services": {
+    "search": [
+      {
+        "id": "0x1415F11",
+        "latency_us": 877909,
+        "remote": "centos7-lx1.home.ingenthron.org:8094",
+        "local": "127.0.0.1:54669",
+        "state": "ok"
+      }
+    ],
+    "kv": [
+      {
+        "id": "0x1415F12",
+        "latency_us": 1182000,
+        "remote": "centos7-lx1.home.ingenthron.org:11210",
+        "local": "127.0.0.1:54670",
+        "state": "ok",
+        "namespace": "bucketname"
+      }
+    ],
+    "query": [
+      {
+        "id": "0x1415F14",
+        "latency_us": 2213,
+        "remote": "centos7-lx2.home.ingenthron.org:8095",
+        "local": "127.0.0.1:54682",
+        "state": "timeout"
+      }
+    ],
+    "analytics": [
+      {
+        "id": "0x1415F15",
+        "latency_us": 2213,
+        "remote": "centos7-lx1.home.ingenthron.org:8095",
+        "local": "127.0.0.1:54675",
+        "state": "error",
+        "error": "endpoint returned HTTP code 500!"
+      }
+    ],
+    "views": [
+      {
+        "id": "0x1415F16",
+        "latency_us": 45585,
+        "remote": "centos7-lx1.home.ingenthron.org:8092",
+        "local": "127.0.0.1:54672",
+        "state": "ok"
+      }
+    ]
+  }
+}
+)");
+    auto report = tao::json::value(res);
+    REQUIRE(report == expected);
+}
+
+TEST_CASE("native: fetch diagnostics after N1QL query", "[native]")
+{
+    auto ctx = test_context::load_from_environment();
+    native_init_logger();
+
+    auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
+    couchbase::cluster_credentials auth{};
+    auth.username = ctx.username;
+    auth.password = ctx.password;
+
+    asio::io_context io;
+
+    couchbase::cluster cluster(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(couchbase::origin(auth, connstr), [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        cluster.open_bucket(ctx.bucket, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    {
+        couchbase::operations::query_request req{ "SELECT 'hello, couchbase' AS greetings" };
+        auto barrier = std::make_shared<std::promise<couchbase::operations::query_response>>();
+        auto f = barrier->get_future();
+        cluster.execute_http(req, [barrier](couchbase::operations::query_response&& resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        INFO(resp.ctx.ec.message());
+        REQUIRE_FALSE(resp.ctx.ec);
+        INFO("rows.size() =" << resp.payload.rows.size());
+        REQUIRE(resp.payload.rows.size() == 1);
+        INFO("row=" << resp.payload.rows[0]);
+        REQUIRE(resp.payload.rows[0] == R"({"greetings":"hello, couchbase"})");
+    }
+    {
+        auto barrier = std::make_shared<std::promise<couchbase::diag::diagnostics_result>>();
+        auto f = barrier->get_future();
+        cluster.diagnostics("my_report_id", [barrier](couchbase::diag::diagnostics_result&& resp) mutable { barrier->set_value(resp); });
+        auto res = f.get();
+        REQUIRE(res.id == "my_report_id");
+        REQUIRE(res.sdk.find("ruby/") == 0);
+        REQUIRE(res.services[couchbase::service_type::kv].size() > 1);
+        REQUIRE(res.services[couchbase::service_type::query].size() == 1);
+        REQUIRE(res.services[couchbase::service_type::query][0].state == couchbase::diag::endpoint_state::connected);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<void>>();
+        auto f = barrier->get_future();
+        cluster.close([barrier]() { barrier->set_value(); });
+        f.get();
+    }
+
+    io_thread.join();
+}
+
+TEST_CASE("native: ping", "[native]")
+{
+    auto ctx = test_context::load_from_environment();
+    native_init_logger();
+
+    auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
+    couchbase::cluster_credentials auth{};
+    auth.username = ctx.username;
+    auth.password = ctx.password;
+
+    asio::io_context io;
+
+    couchbase::cluster cluster(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(couchbase::origin(auth, connstr), [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<std::error_code>>();
+        auto f = barrier->get_future();
+        cluster.open_bucket(ctx.bucket, [barrier](std::error_code ec) mutable { barrier->set_value(ec); });
+        auto rc = f.get();
+        INFO(rc.message());
+        REQUIRE_FALSE(rc);
+    }
+    {
+        auto barrier = std::make_shared<std::promise<couchbase::diag::ping_result>>();
+        auto f = barrier->get_future();
+        cluster.ping("my_report_id", {}, {}, [barrier](couchbase::diag::ping_result&& resp) mutable { barrier->set_value(resp); });
+        auto res = f.get();
+        REQUIRE(res.id == "my_report_id");
+        REQUIRE(res.sdk.find("ruby/") == 0);
+
+        auto report = tao::json::value(res);
+        spdlog::critical("XXX {}", tao::json::to_string(report));
+    }
+    {
+        auto barrier = std::make_shared<std::promise<void>>();
+        auto f = barrier->get_future();
+        cluster.close([barrier]() { barrier->set_value(); });
+        f.get();
+    }
+
+    io_thread.join();
+}