couchbase 3.2.3 → 3.2.4

package/deps/lcb/tests/iotests/mock-unit-test.cc

@@ -20,7 +20,7 @@
 
 #include "internal.h" /* vbucket_* things from lcb_INSTANCE **/
 #include <lcbio/iotable.h>
-#include "bucketconfig/bc_http.h"
+#include "libcouchbase/couchbase.h"
 
 #define LOGARGS(instance, lvl) instance->settings, "tests-MUT", LCB_LOG_##lvl, __FILE__, __LINE__
 
@@ -29,7 +29,7 @@
  */
 void MockUnitTest::SetUp()
 {
-    srand(time(NULL));
+    srand(time(nullptr));
     MockEnvironment::Reset();
 }
 
@@ -42,8 +42,8 @@ void checkConnectCommon(lcb_INSTANCE *instance)
 
 void MockUnitTest::createClusterConnection(HandleWrap &handle, lcb_INSTANCE **instance)
 {
-    lcb_CREATEOPTS *options = NULL;
-    MockEnvironment::getInstance()->makeConnectParams(options, NULL, LCB_TYPE_CLUSTER);
+    lcb_CREATEOPTS *options = nullptr;
+    MockEnvironment::getInstance()->makeConnectParams(options, nullptr, LCB_TYPE_CLUSTER);
     MockEnvironment::getInstance()->createConnection(handle, instance, options);
     checkConnectCommon(handle.getLcb());
     lcb_createopts_destroy(options);
@@ -70,7 +70,7 @@ void MockUnitTest::createConnection(lcb_INSTANCE **instance)
 
 void MockUnitTest::createConnection(HandleWrap &handle)
 {
-    lcb_INSTANCE *instance = NULL;
+    lcb_INSTANCE *instance = nullptr;
     createConnection(handle, &instance);
 }
 
@@ -81,3 +81,94 @@ lcb_STATUS MockUnitTest::tryCreateConnection(HandleWrap &hw, lcb_INSTANCE **inst
     lcb_wait(*instance, LCB_WAIT_DEFAULT);
     return lcb_get_bootstrap_status(*instance);
 }
+
+void MockUnitTest::assert_kv_span(const std::shared_ptr<TestSpan> &span, const std::string &expectedName,
+                                  const KVSpanAssertions &assertions)
+{
+    auto bucket = MockEnvironment::getInstance()->getBucket();
+    ASSERT_EQ(expectedName, span->name);
+    ASSERT_EQ("couchbase", span->str_tags["db.system"]);
+    ASSERT_TRUE(span->int_tags.find("db.couchbase.server_duration") != span->int_tags.end());
+    ASSERT_EQ(bucket, span->str_tags["db.name"]);
+    ASSERT_EQ(assertions.scope, span->str_tags["db.couchbase.scope"]);
+    ASSERT_EQ(assertions.collection, span->str_tags["db.couchbase.collection"]);
+    ASSERT_EQ("kv", span->str_tags["db.couchbase.service"]);
+    ASSERT_EQ(expectedName, span->str_tags["db.operation"]);
+    ASSERT_EQ("IP.TCP", span->str_tags["net.transport"]);
+    ASSERT_TRUE(span->str_tags.count("db.couchbase.operation_id") > 0);
+    ASSERT_TRUE(span->str_tags.count("db.couchbase.local_id") > 0);
+    ASSERT_TRUE(span->str_tags.count("net.host.name") > 0);
+    ASSERT_TRUE(span->str_tags.count("net.host.port") > 0);
+    ASSERT_TRUE(span->str_tags.count("net.peer.name") > 0);
+    ASSERT_TRUE(span->str_tags.count("net.peer.port") > 0);
+    ASSERT_TRUE(span->int_tags.count("db.couchbase.retries") > 0);
+    if (assertions.durability_level == LCB_DURABILITYLEVEL_NONE) {
+        ASSERT_TRUE(span->str_tags.count("db.couchbase.durability") == 0);
+    } else {
+        ASSERT_EQ(dur_level_to_string(assertions.durability_level), span->str_tags["db.couchbase.durability"]);
+    }
+    ASSERT_TRUE(span->finished);
+}
+
+void MockUnitTest::assert_http_span(const std::shared_ptr<TestSpan> &span, const std::string &expectedName,
+                                    const HTTPSpanAssertions &assertions)
+{
+    ASSERT_EQ(expectedName, span->name);
+    ASSERT_EQ("couchbase", span->str_tags["db.system"]);
+    if (!assertions.bucket.empty()) {
+        ASSERT_EQ(assertions.bucket, span->str_tags["db.name"]);
+    }
+    if (!assertions.scope.empty()) {
+        ASSERT_EQ(assertions.scope, span->str_tags["db.couchbase.scope"]);
+    }
+    if (!assertions.collection.empty()) {
+        ASSERT_EQ(assertions.collection, span->str_tags["db.couchbase.collection"]);
+    }
+    if (!assertions.service.empty()) {
+        ASSERT_EQ(assertions.service, span->str_tags["db.couchbase.service"]);
+    }
+    if (!assertions.op.empty()) {
+        ASSERT_EQ(assertions.op, span->str_tags["db.operation"]);
+    }
+    ASSERT_EQ("IP.TCP", span->str_tags["net.transport"]);
+    if (assertions.operation_id.empty()) {
+        ASSERT_TRUE(span->str_tags.find("db.couchbase.operation_id") == span->str_tags.end());
+    } else if (assertions.operation_id == "any") {
+        ASSERT_TRUE(span->str_tags.find("db.couchbase.operation_id") != span->str_tags.end());
+    } else {
+        ASSERT_EQ(assertions.operation_id, span->str_tags["db.couchbase.operation_id"]);
+    }
+    ASSERT_TRUE(span->str_tags.find("net.host.name") != span->str_tags.end());
+    ASSERT_TRUE(span->str_tags.find("net.host.port") != span->str_tags.end());
+    ASSERT_TRUE(span->str_tags.find("net.peer.name") != span->str_tags.end());
+    ASSERT_TRUE(span->str_tags.find("net.peer.port") != span->str_tags.end());
+    ASSERT_TRUE(span->int_tags.find("db.couchbase.retries") != span->int_tags.end());
+    if (!assertions.statement.empty()) {
+        ASSERT_EQ(assertions.statement, span->str_tags["db.statement"]);
+    }
+    ASSERT_TRUE(span->finished);
+}
+
+void MockUnitTest::assert_kv_metrics(const std::string &metric_name, const std::string &op, uint32_t length,
+                                     bool at_least_len)
+{
+    std::string key = metric_name + ":kv";
+    if (op != "") {
+        key = key + ":" + op;
+    }
+    assert_metrics(key, length, at_least_len);
+}
+
+void MockUnitTest::assert_metrics(const std::string &key, uint32_t length, bool at_least_len)
+{
+    auto meter = MockEnvironment::getInstance()->getMeter();
+    ASSERT_TRUE(meter.recorders.find(key) != meter.recorders.end());
+    if (at_least_len) {
+        ASSERT_TRUE(meter.recorders[key]->values.size() >= length);
+    } else {
+        ASSERT_TRUE(meter.recorders[key]->values.size() == length);
+    }
+    for (const auto value : meter.recorders[key]->values) {
+        ASSERT_NE(0, value);
+    }
+}

package/deps/lcb/tests/iotests/mock-unit-test.h

@@ -21,6 +21,7 @@
 #include <gtest/gtest.h>
 #include <libcouchbase/couchbase.h>
 #include "mock-environment.h"
+#include "testutil.h"
 
 class HandleWrap;
 
@@ -44,6 +45,22 @@ class HandleWrap;
         return;                                                                                                        \
     }
 
+struct KVSpanAssertions {
+    lcb_DURABILITY_LEVEL durability_level{LCB_DURABILITYLEVEL_NONE};
+    std::string scope{"_default"};
+    std::string collection{"_default"};
+};
+
+struct HTTPSpanAssertions {
+    std::string statement{};
+    std::string scope{};
+    std::string collection{};
+    std::string bucket{};
+    std::string op{};
+    std::string operation_id{};
+    std::string service{};
+};
+
 class MockUnitTest : public ::testing::Test
 {
   protected:
@@ -56,6 +73,13 @@ class MockUnitTest : public ::testing::Test
     virtual void createClusterConnection(HandleWrap &handle, lcb_INSTANCE **instance);
     virtual lcb_STATUS tryCreateConnection(HandleWrap &hw, lcb_INSTANCE **instance, lcb_CREATEOPTS *&crparams);
 
+    static void assert_kv_span(const std::shared_ptr<TestSpan> &span, const std::string &expectedName,
+                               const KVSpanAssertions &assertions);
+    static void assert_http_span(const std::shared_ptr<TestSpan> &span, const std::string &expectedName,
+                                 const HTTPSpanAssertions &assertions);
+    void assert_kv_metrics(const std::string &metric_name, const std::string &op, uint32_t length, bool at_least_len);
+    void assert_metrics(const std::string &key, uint32_t length, bool at_least_len);
+
     // A mock "Transaction"
     void doMockTxn(MockCommand &cmd)
     {
@@ -66,4 +90,12 @@ class MockUnitTest : public ::testing::Test
     }
 };
 
+/*
+ * This test class groups tests that might be problematic when executed together with all other tests.
+ * Every test case in this suite must start with Jira ticket number for future.
+ */
+class ContaminatingUnitTest : public MockUnitTest
+{
+};
+
 #endif

package/deps/lcb/tests/iotests/t_collections.cc

@@ -572,7 +572,7 @@ TEST_F(CollectionUnitTest, testDroppedScope)
  *
  * Collection creations are successful
  */
-TEST_F(CollectionUnitTest, testMaxCollectionsPerScope)
+TEST_F(ContaminatingUnitTest, test_CCBC_1483_MaxCollectionsPerScope)
 {
     SKIP_IF_MOCK()
     SKIP_IF_CLUSTER_VERSION_IS_LOWER_THAN(MockEnvironment::VERSION_70)

package/deps/lcb/tests/iotests/t_confmon.cc

@@ -24,6 +24,9 @@ struct evstop_listener : Listener {
 
     void clconfig_lsn(EventType event, ConfigInfo *)
     {
+        if (event == CLCONFIG_EVENT_PROVIDERS_CYCLED) {
+            return IOT_STOP(io);
+        }
         if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
             return;
         }
@@ -40,7 +43,6 @@ static void listen_callback1(Listener *lsn, EventType event, ConfigInfo *info) {
 
 TEST_F(ConfmonTest, testBasic)
 {
-    SKIP_UNLESS_MOCK();
     HandleWrap hw;
     lcb_INSTANCE *instance;
     MockEnvironment::getInstance()->createConnection(hw, &instance);
@@ -68,8 +70,8 @@ TEST_F(ConfmonTest, testBasic)
     mon->start();
 
     IOT_START(instance->iotable);
-    ASSERT_NE(0, listener.called);
     delete mon;
+    ASSERT_NE(0, listener.called);
 }
 
 struct listener2 : Listener {

package/deps/lcb/tests/iotests/t_get.cc

@@ -21,6 +21,7 @@
 #include "iotests.h"
 #include "logging.h"
 #include "internal.h"
+#include "testutil.h"
 
 #define LOGARGS(instance, lvl) instance->settings, "tests-GET", LCB_LOG_##lvl, __FILE__, __LINE__
 
@@ -106,6 +107,9 @@ static void testGetHitGetCallback(lcb_INSTANCE *, lcb_CALLBACK_TYPE, const lcb_R
  */
 TEST_F(GetUnitTest, testGetHit)
 {
+    MockEnvironment *mock = MockEnvironment::getInstance();
+    tracing_guard use_tracing;
+    metrics_guard use_metrics;
     HandleWrap hw;
     lcb_INSTANCE *instance;
     createConnection(hw, &instance);
@@ -129,6 +133,16 @@ TEST_F(GetUnitTest, testGetHit)
 
     lcb_wait(instance, LCB_WAIT_DEFAULT);
     EXPECT_EQ(2, numcallbacks);
+
+    auto spans = mock->getTracer().spans;
+    ASSERT_EQ(4, spans.size());
+    auto span = spans[0];
+    assert_kv_span(span, "upsert", {});
+    span = spans[2];
+    assert_kv_span(span, "get", {});
+
+    assert_kv_metrics(METRICS_OPS_METER_NAME, "get", 2, false);
+    assert_kv_metrics(METRICS_OPS_METER_NAME, "upsert", 2, false);
 }
 
 extern "C" {
@@ -1097,10 +1111,6 @@ TEST_F(GetUnitTest, testChangePassword)
     createConnection(hwHttp, &instanceHttp);
     (void)lcb_install_callback(instanceHttp, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)change_password_http_callback);
 
-    // Set short timeout
-    lcb_uint32_t tmoval = 100000;
-    lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_OP_TIMEOUT, &tmoval);
-
     // store keys
     // run one set to connect to only one node
     // the goal is to change the password then try to connect others nodes

package/deps/lcb/tests/iotests/t_n1ql.cc

@@ -165,6 +165,8 @@ class QueryUnitTest : public MockUnitTest
 
 TEST_F(QueryUnitTest, testSimple)
 {
+    MockEnvironment *mock = MockEnvironment::getInstance();
+    tracing_guard use_tracing;
     lcb_INSTANCE *instance;
     HandleWrap hw;
     if (!createQueryConnection(hw, &instance)) {
@@ -172,12 +174,26 @@ TEST_F(QueryUnitTest, testSimple)
     }
 
     N1QLResult res;
-    makeCommand("SELECT mockrow");
+    const char *query = "SELECT mockrow";
+    makeCommand(query);
+
+    const char *context_id = "context_id";
+    lcb_cmdquery_client_context_id(cmd, context_id, strlen(context_id));
+
     lcb_STATUS rc = lcb_query(instance, &res, cmd);
     ASSERT_STATUS_EQ(LCB_SUCCESS, rc);
     lcb_wait(instance, LCB_WAIT_DEFAULT);
     ASSERT_STATUS_EQ(LCB_SUCCESS, res.rc);
     ASSERT_EQ(1, res.rows.size());
+
+    auto spans = mock->getTracer().spans;
+    ASSERT_EQ(1, spans.size());
+    auto span = spans[0];
+    HTTPSpanAssertions assertions;
+    assertions.statement = query;
+    assertions.operation_id = context_id;
+    assertions.service = "query";
+    assert_http_span(span, "query", assertions);
 }
 
 TEST_F(QueryUnitTest, testQueryError)

package/deps/lcb/tests/iotests/t_views.cc

@@ -243,6 +243,7 @@ TEST_F(ViewsUnitTest, testSimpleView)
 {
     SKIP_UNLESS_MOCK();
     // Requires beer-sample
+    MockEnvironment *mock = MockEnvironment::getInstance();
     HandleWrap hw;
     lcb_INSTANCE *instance;
     connectBeerSample(hw, &instance);

package/deps/lcb/tests/iotests/testutil.cc

@@ -316,6 +316,10 @@ static std::uint64_t get_manifest_id(lcb_INSTANCE *instance)
     lcb_cmdgetmanifest_destroy(cmd);
     lcb_wait(instance, LCB_WAIT_DEFAULT);
 
+    if (result.rc == LCB_ERR_TIMEOUT) {
+        return 0;
+    }
+
     Json::Value payload;
     EXPECT_EQ(LCB_SUCCESS, result.rc);
     EXPECT_FALSE(result.value.empty());
@@ -461,3 +465,167 @@ std::string unique_name(const std::string &prefix)
     ss << prefix << lcb_next_rand32();
     return ss.str();
 }
+
+void TestSpan::SetAttribute(std::string key, uint64_t value)
+{
+    int_tags[std::move(key)] = value;
+}
+
+void TestSpan::SetAttribute(std::string key, std::string value)
+{
+    str_tags[std::move(key)] = std::move(value);
+}
+
+void TestSpan::End()
+{
+    finished = true;
+}
+
+TestSpan::TestSpan(std::string span_name)
+{
+    name = std::move(span_name);
+}
+
+std::shared_ptr<TestSpan> TestTracer::StartSpan(std::string name)
+{
+    auto t_span = std::make_shared<TestSpan>(name);
+    spans.push_back(t_span);
+    return t_span;
+}
+
+void TestTracer::reset()
+{
+    spans.clear();
+}
+
+static void *start_span(lcbtrace_TRACER *tracer, const char *name, void *parent)
+{
+    auto test_tracer = static_cast<TestTracer *>(tracer->cookie);
+    if (!test_tracer->enabled()) {
+        return nullptr;
+    }
+    auto test_span = test_tracer->StartSpan(std::string(name));
+    return test_span.get();
+}
+
+static void end_span(void *span)
+{
+    if (span == nullptr) {
+        return;
+    }
+    static_cast<TestSpan *>(span)->End();
+}
+
+static void add_tag_string(void *span, const char *name, const char *value, size_t value_len)
+{
+    if (span == nullptr) {
+        return;
+    }
+    std::string val;
+    val.append(value, value_len);
+    static_cast<TestSpan *>(span)->SetAttribute(std::string(name), val);
+}
+
+static void add_tag_uint64(void *span, const char *name, uint64_t value)
+{
+    if (span == nullptr) {
+        return;
+    }
+    static_cast<TestSpan *>(span)->SetAttribute(name, value);
+}
+
+void TestTracer::create_lcb_tracer()
+{
+    lcbtracer_ = lcbtrace_new(nullptr, LCBTRACE_F_EXTERNAL);
+    lcbtracer_->version = 1;
+    lcbtracer_->v.v1.start_span = start_span;
+    lcbtracer_->v.v1.end_span = end_span;
+    lcbtracer_->v.v1.add_tag_string = add_tag_string;
+    lcbtracer_->v.v1.add_tag_uint64 = add_tag_uint64;
+    lcbtracer_->cookie = static_cast<void *>(this);
+}
+
+void TestTracer::destroy_lcb_tracer()
+{
+    if (lcbtracer_ != nullptr) {
+        lcbtrace_destroy(lcbtracer_);
+        delete lcbtracer_;
+        lcbtracer_ = nullptr;
+    }
+}
+
+TestTracer::~TestTracer()
+{
+    destroy_lcb_tracer();
+}
+
+TestMeter::TestMeter() = default;
+
+void TestMeter::reset()
+{
+    recorders.clear();
+}
+
+void TestValueRecorder::RecordValue(uint64_t value)
+{
+    values.push_back(value);
+}
+
+std::shared_ptr<TestValueRecorder> TestMeter::ValueRecorder(std::string name,
+                                                            std::unordered_map<std::string, std::string> tags)
+{
+    auto key = name + ":" + tags["db.couchbase.service"];
+    auto op = tags["db.operation"];
+    if (!op.empty()) {
+        key = key + ":" + op;
+    }
+    std::shared_ptr<TestValueRecorder> test_recorder;
+    if (recorders.find(key) == recorders.end()) {
+        test_recorder = std::make_shared<TestValueRecorder>();
+        recorders[key] = test_recorder;
+    } else {
+        test_recorder = recorders[key];
+    }
+    return test_recorder;
+}
+
+static void record_callback(const lcbmetrics_VALUERECORDER *recorder, uint64_t value)
+{
+    void *test_recorder;
+    lcbmetrics_valuerecorder_cookie(recorder, &test_recorder);
+    static_cast<TestValueRecorder *>(test_recorder)->RecordValue(value);
+}
+
+static const lcbmetrics_VALUERECORDER *new_recorder(const lcbmetrics_METER *meter, const char *name,
+                                                    const lcbmetrics_TAG *tags, size_t ntags)
+{
+    std::unordered_map<std::string, std::string> recorder_tags;
+    for (int i = 0; i < ntags; i++) {
+        recorder_tags[tags[i].key] = tags[i].value;
+    }
+
+    void *test_meter_;
+    lcbmetrics_meter_cookie(meter, &test_meter_);
+    auto test_meter = static_cast<TestMeter *>(test_meter_);
+    auto test_value_recorder = test_meter->ValueRecorder(std::string(name), recorder_tags);
+
+    lcbmetrics_VALUERECORDER *recorder;
+    lcbmetrics_valuerecorder_create(&recorder, test_value_recorder.get());
+    lcbmetrics_valuerecorder_record_value_callback(recorder, record_callback);
+
+    return recorder;
+}
+
+void TestMeter::create_lcb_meter()
+{
+    lcbmetrics_meter_create(&lcbmeter_, static_cast<void *>(this));
+    lcbmetrics_meter_value_recorder_callback(lcbmeter_, new_recorder);
+}
+
+void TestMeter::destroy_lcb_meter()
+{
+    if (lcbmeter_ != nullptr) {
+        lcbmetrics_meter_destroy(lcbmeter_);
+        lcbmeter_ = nullptr;
+    }
+}

package/deps/lcb/tests/iotests/testutil.h

@@ -20,6 +20,8 @@
 #include <libcouchbase/couchbase.h>
 #include <libcouchbase/vbucket.h>
 #include <string>
+#include <memory>
+#include <unordered_map>
 
 #define ASSERT_STATUS_EQ(expected, actual)                                                                             \
     lcb_STATUS GTEST_CONCAT_TOKEN_(actual_code__, __LINE__) = (actual);                                                \
@@ -212,4 +214,113 @@ void drop_scope(lcb_INSTANCE *instance, const std::string &scope, bool wait = tr
 void drop_collection(lcb_INSTANCE *instance, const std::string &scope, const std::string &collection, bool wait = true);
 
 std::string unique_name(const std::string &);
+
+class TestSpan
+{
+  public:
+    explicit TestSpan(std::string name);
+    void SetAttribute(std::string key, std::string value);
+    void SetAttribute(std::string key, uint64_t value);
+    void End();
+
+    std::unordered_map<std::string, std::string> str_tags{};
+    std::unordered_map<std::string, uint64_t> int_tags{};
+    bool finished{false};
+    std::string name{};
+
+    TestSpan *parent{nullptr};
+};
+
+class TestTracer
+{
+  public:
+    TestTracer() = default;
+    ~TestTracer();
+    std::shared_ptr<TestSpan> StartSpan(std::string name);
+
+    std::vector<std::shared_ptr<TestSpan>> spans{};
+
+    void reset();
+
+    bool set_enabled(bool new_value)
+    {
+        bool old_value = enabled_;
+        enabled_ = new_value;
+
+        reset();
+        destroy_lcb_tracer();
+        if (new_value) {
+            create_lcb_tracer();
+        }
+        return old_value;
+    }
+
+    bool enabled() const
+    {
+        return enabled_;
+    }
+
+    lcbtrace_TRACER *lcb_tracer()
+    {
+        return lcbtracer_;
+    }
+
+  private:
+    void create_lcb_tracer();
+    void destroy_lcb_tracer();
+
+    lcbtrace_TRACER *lcbtracer_{nullptr};
+    bool enabled_{false};
+};
+
+class TestValueRecorder
+{
+  public:
+    TestValueRecorder() = default;
+    void RecordValue(uint64_t value);
+
+    std::vector<uint64_t> values{};
+};
+
+class TestMeter
+{
+  public:
+    TestMeter();
+    void reset();
+    std::shared_ptr<TestValueRecorder> ValueRecorder(std::string name,
+                                                     std::unordered_map<std::string, std::string> tags);
+
+    std::unordered_map<std::string, std::shared_ptr<TestValueRecorder>> recorders{};
+
+    bool set_enabled(bool new_value)
+    {
+        bool old_value = enabled_;
+        enabled_ = new_value;
+
+        reset();
+        destroy_lcb_meter();
+        if (new_value) {
+            create_lcb_meter();
+        }
+        return old_value;
+    }
+
+    bool enabled() const
+    {
+        return enabled_;
+    }
+
+    lcbmetrics_METER *lcb_meter()
+    {
+        return lcbmeter_;
+    }
+
+  private:
+    void create_lcb_meter();
+    void destroy_lcb_meter();
+
+    lcbmetrics_METER *lcbmeter_{nullptr};
+    bool enabled_{false};
+};
+
 #endif