couchbase 3.2.0 → 3.2.4

package/deps/lcb/tests/iotests/mock-environment.h

@@ -20,6 +20,7 @@
 #include "config.h"
 #include <gtest/gtest.h>
 #include <libcouchbase/couchbase.h>
+#include "testutil.h"
 
 #include <utility>
 #include "serverparams.h"
@@ -407,6 +408,8 @@ class MockEnvironment : public ::testing::Environment
     void createConnection(lcb_INSTANCE **instance);
 
     void createConnection(HandleWrap &handle, lcb_INSTANCE **instance);
+    void createConnection(HandleWrap &handle, lcb_INSTANCE **instance, const std::string &username,
+                          const std::string &password);
     void createConnection(HandleWrap &handle, lcb_INSTANCE **instance, const lcb_CREATEOPTS *options) const;
 
     /**
@@ -449,6 +452,16 @@ class MockEnvironment : public ::testing::Environment
         std::cerr << std::endl;
     }
 
+    TestTracer &getTracer()
+    {
+        return test_tracer;
+    }
+
+    TestMeter &getMeter()
+    {
+        return test_meter;
+    }
+
     explicit MockEnvironment(const char **argv, const std::string &name = "default");
     ~MockEnvironment() override;
     void postCreate(lcb_INSTANCE *instance) const;
@@ -476,11 +489,47 @@ class MockEnvironment : public ::testing::Environment
     std::string userName;
     const char **argv_{nullptr};
     void clearAndReset();
+    TestTracer test_tracer;
+    TestMeter test_meter;
 
   private:
     lcb_INSTANCE *innerClient{nullptr};
 };
 
+class tracing_guard
+{
+  public:
+    tracing_guard()
+    {
+        was_enabled_ = MockEnvironment::getInstance()->getTracer().set_enabled(true);
+    }
+
+    ~tracing_guard()
+    {
+        MockEnvironment::getInstance()->getTracer().set_enabled(was_enabled_);
+    }
+
+  private:
+    bool was_enabled_{false};
+};
+
+class metrics_guard
+{
+  public:
+    metrics_guard()
+    {
+        was_enabled_ = MockEnvironment::getInstance()->getMeter().set_enabled(true);
+    }
+
+    ~metrics_guard()
+    {
+        MockEnvironment::getInstance()->getMeter().set_enabled(was_enabled_);
+    }
+
+  private:
+    bool was_enabled_{false};
+};
+
 #define LCB_TEST_REQUIRE_CLUSTER_VERSION(v)                                                                            \
     if (!MockEnvironment::getInstance()->isRealCluster()) {                                                            \
         MockEnvironment::printSkipMessage(__FILE__, __LINE__, "need real cluster");                                    \

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,21 +29,21 @@
  */
 void MockUnitTest::SetUp()
 {
-    srand(time(NULL));
+    srand(time(nullptr));
     MockEnvironment::Reset();
 }
 
 void checkConnectCommon(lcb_INSTANCE *instance)
 {
-    ASSERT_EQ(LCB_SUCCESS, lcb_connect(instance));
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_connect(instance));
     lcb_wait(instance, LCB_WAIT_DEFAULT);
     ASSERT_EQ(LCB_SUCCESS, lcb_get_bootstrap_status(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);
@@ -55,6 +55,13 @@ void MockUnitTest::createConnection(HandleWrap &handle, lcb_INSTANCE **instance)
     checkConnectCommon(handle.getLcb());
 }
 
+void MockUnitTest::createConnection(HandleWrap &handle, lcb_INSTANCE **instance, const std::string &username,
+                                    const std::string &password)
+{
+    MockEnvironment::getInstance()->createConnection(handle, instance, username, password);
+    checkConnectCommon(handle.getLcb());
+}
+
 void MockUnitTest::createConnection(lcb_INSTANCE **instance)
 {
     MockEnvironment::getInstance()->createConnection(instance);
@@ -63,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);
 }
 
@@ -74,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:
@@ -51,9 +68,18 @@ class MockUnitTest : public ::testing::Test
     virtual void createConnection(lcb_INSTANCE **instance);
     virtual void createConnection(HandleWrap &handle);
     virtual void createConnection(HandleWrap &handle, lcb_INSTANCE **instance);
+    virtual void createConnection(HandleWrap &handle, lcb_INSTANCE **instance, const std::string &username,
+                                  const std::string &password);
     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)
     {
@@ -64,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" {
@@ -845,6 +859,7 @@ TEST_F(GetUnitTest, testPessimisticLock)
     lcb_install_callback(instance, LCB_CALLBACK_UNLOCK, reinterpret_cast<lcb_RESPCALLBACK>(pl_unlock_callback));
 
     std::string key(unique_name("testPessimisticLock"));
+    std::uint32_t lock_time_s = 10;
 
     std::uint64_t cas{0};
     {
@@ -870,7 +885,7 @@ TEST_F(GetUnitTest, testPessimisticLock)
         lcb_CMDGET *cmd = nullptr;
         lcb_cmdget_create(&cmd);
         lcb_cmdget_key(cmd, key.c_str(), key.size());
-        lcb_cmdget_locktime(cmd, 5);
+        lcb_cmdget_locktime(cmd, lock_time_s);
         lcb_get(instance, &res, cmd);
         lcb_cmdget_destroy(cmd);
         lcb_wait(instance, LCB_WAIT_DEFAULT);
@@ -902,7 +917,7 @@ TEST_F(GetUnitTest, testPessimisticLock)
         lcb_CMDGET *cmd = nullptr;
         lcb_cmdget_create(&cmd);
         lcb_cmdget_key(cmd, key.c_str(), key.size());
-        lcb_cmdget_locktime(cmd, 5);
+        lcb_cmdget_locktime(cmd, lock_time_s);
         lcb_get(instance, &res, cmd);
         lcb_cmdget_destroy(cmd);
         lcb_wait(instance, LCB_WAIT_DEFAULT);
@@ -949,7 +964,7 @@ TEST_F(GetUnitTest, testPessimisticLock)
         lcb_CMDGET *cmd = nullptr;
         lcb_cmdget_create(&cmd);
         lcb_cmdget_key(cmd, key.c_str(), key.size());
-        lcb_cmdget_locktime(cmd, 5);
+        lcb_cmdget_locktime(cmd, lock_time_s);
         lcb_get(instance, &res, cmd);
         lcb_cmdget_destroy(cmd);
         lcb_wait(instance, LCB_WAIT_DEFAULT);
@@ -1096,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
@@ -1179,3 +1190,94 @@ TEST_F(GetUnitTest, testChangePassword)
     }
     EXPECT_EQ(nbCallbacks, counter);
 }
+
+struct touch_result {
+    bool called{false};
+    lcb_STATUS rc{LCB_ERR_GENERIC};
+};
+
+struct gat_result {
+    bool called{false};
+    lcb_STATUS rc{LCB_ERR_GENERIC};
+    std::string value{};
+};
+
+extern "C" {
+static void test_touch_zero_reset(lcb_INSTANCE *, lcb_CALLBACK_TYPE, const lcb_RESPTOUCH *resp)
+{
+    touch_result *result;
+    lcb_resptouch_cookie(resp, (void **)&result);
+    result->called = true;
+    result->rc = lcb_resptouch_status(resp);
+}
+
+static void test_get_and_touch_zero_reset(lcb_INSTANCE *, lcb_CALLBACK_TYPE, const lcb_RESPGET *resp)
+{
+    gat_result *result;
+    lcb_respget_cookie(resp, (void **)&result);
+    result->called = true;
+    result->rc = lcb_respget_status(resp);
+    const char *value = nullptr;
+    std::size_t value_len = 0;
+    lcb_respget_value(resp, &value, &value_len);
+    if (value_len > 0 && value != nullptr) {
+        result->value.assign(value, value_len);
+    }
+}
+}
+
+TEST_F(GetUnitTest, testTouchWithZeroExpiryResetsExpiry)
+{
+    std::string key = unique_name("gat_reset_expiry_key");
+    std::string value = unique_name("gat_reset_expiry_value");
+
+    HandleWrap hw;
+    lcb_INSTANCE *instance;
+    createConnection(hw, &instance);
+
+    (void)lcb_install_callback(instance, LCB_CALLBACK_TOUCH, (lcb_RESPCALLBACK)test_touch_zero_reset);
+    (void)lcb_install_callback(instance, LCB_CALLBACK_GET, (lcb_RESPCALLBACK)test_get_and_touch_zero_reset);
+    storeKey(instance, key, value);
+
+    {
+        touch_result res{};
+        lcb_CMDTOUCH *cmd;
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdtouch_create(&cmd));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdtouch_key(cmd, key.c_str(), key.size()));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdtouch_expiry(cmd, 1));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_touch(instance, &res, cmd));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdtouch_destroy(cmd));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+        ASSERT_TRUE(res.called);
+        ASSERT_STATUS_EQ(LCB_SUCCESS, res.rc);
+    }
+
+    {
+        gat_result res{};
+        lcb_CMDGET *cmd;
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdget_create(&cmd));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdget_key(cmd, key.c_str(), key.size()));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdget_expiry(cmd, 0));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_get(instance, &res, cmd));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdget_destroy(cmd));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+        ASSERT_TRUE(res.called);
+        ASSERT_STATUS_EQ(LCB_SUCCESS, res.rc);
+        ASSERT_EQ(value, res.value);
+    }
+
+    sleep(2);
+
+    {
+        gat_result res{};
+        lcb_CMDGET *cmd;
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdget_create(&cmd));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdget_key(cmd, key.c_str(), key.size()));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_get(instance, &res, cmd));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdget_destroy(cmd));
+        ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_wait(instance, LCB_WAIT_DEFAULT));
+        ASSERT_TRUE(res.called);
+        ASSERT_STATUS_EQ(LCB_SUCCESS, res.rc);
+        ASSERT_EQ(value, res.value);
+    }
+}

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

@@ -464,9 +464,11 @@ TEST_F(HttpUnitTest, testCancelWorks)
 }
 
 extern "C" {
-static void noInvoke_callback(lcb_INSTANCE *, int, const lcb_RESPBASE *)
+static void noInvoke_callback(lcb_INSTANCE *, int, const lcb_RESPHTTP *resp)
 {
-    EXPECT_FALSE(true) << "This callback should not be invoked!";
+    bool *called;
+    lcb_resphttp_cookie(resp, (void **)&called);
+    *called = true;
 }
 }
 TEST_F(HttpUnitTest, testDestroyWithActiveRequest)
@@ -481,10 +483,13 @@ TEST_F(HttpUnitTest, testDestroyWithActiveRequest)
     std::string ss;
     makeAdminReq(&cmd, ss, instance);
 
-    lcb_install_callback(instance, LCB_CALLBACK_HTTP, noInvoke_callback);
+    lcb_install_callback(instance, LCB_CALLBACK_HTTP, (lcb_RESPCALLBACK)noInvoke_callback);
     lcb_sched_enter(instance);
-    ASSERT_EQ(LCB_SUCCESS, lcb_http(instance, nullptr, cmd));
+    bool called = false;
+    ASSERT_EQ(LCB_SUCCESS, lcb_http(instance, &called, cmd));
     lcb_cmdhttp_destroy(cmd);
     lcb_sched_leave(instance);
+    fprintf(stderr, "invoke lcb_destroy\n");
     lcb_destroy(instance);
+    ASSERT_TRUE(called) << "lcb_destroy should invoke HTTP callbacks";
 }

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

@@ -347,3 +347,21 @@ TEST_F(LockUnitTest, testUnlLockContention)
     getKey(instance, key, gitm);
     ASSERT_EQ(gitm.val, newval);
 }
+
+TEST_F(LockUnitTest, testDoesNotAllowToSwitchModeFromLockToTouch)
+{
+    lcb_CMDGET *cmd;
+    lcb_cmdget_create(&cmd);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdget_locktime(cmd, 5));
+    ASSERT_STATUS_EQ(LCB_ERR_INVALID_ARGUMENT, lcb_cmdget_expiry(cmd, 10));
+    lcb_cmdget_destroy(cmd);
+}
+
+TEST_F(LockUnitTest, testDoesNotAllowToSwitchModeFromTouchToLock)
+{
+    lcb_CMDGET *cmd;
+    lcb_cmdget_create(&cmd);
+    ASSERT_STATUS_EQ(LCB_SUCCESS, lcb_cmdget_expiry(cmd, 5));
+    ASSERT_STATUS_EQ(LCB_ERR_INVALID_ARGUMENT, lcb_cmdget_locktime(cmd, 10));
+    lcb_cmdget_destroy(cmd);
+}