mt-libcouchbase 1.4.0

data/ext/libcouchbase/tests/iotests/t_arithmetic.cc

@@ -0,0 +1,143 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012 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 "config.h"
+#include "iotests.h"
+
+class ArithmeticUnitTest : public MockUnitTest
+{
+};
+
+static lcb_uint64_t arithm_val;
+
+extern "C" {
+    static void arithmetic_incr_callback(lcb_t, const void *,
+                                         lcb_error_t error,
+                                         const lcb_arithmetic_resp_t *resp)
+    {
+        ASSERT_EQ(LCB_SUCCESS, error);
+        ASSERT_EQ(7, resp->v.v0.nkey);
+        ASSERT_EQ(0, memcmp(resp->v.v0.key, "counter", 7));
+        ASSERT_EQ(arithm_val + 1, resp->v.v0.value);
+        arithm_val = resp->v.v0.value;
+    }
+
+    static void arithmetic_decr_callback(lcb_t, const void *,
+                                         lcb_error_t error,
+                                         const lcb_arithmetic_resp_t *resp)
+    {
+        ASSERT_EQ(LCB_SUCCESS, error);
+        ASSERT_EQ(7, resp->v.v0.nkey);
+        ASSERT_EQ(0, memcmp(resp->v.v0.key, "counter", 7));
+        ASSERT_EQ(arithm_val - 1, resp->v.v0.value);
+        arithm_val = resp->v.v0.value;
+    }
+
+    static void arithmetic_create_callback(lcb_t, const void *,
+                                           lcb_error_t error,
+                                           const lcb_arithmetic_resp_t *resp)
+    {
+        ASSERT_EQ(LCB_SUCCESS, error);
+        ASSERT_EQ(9, resp->v.v0.nkey);
+        ASSERT_EQ(0, memcmp(resp->v.v0.key, "mycounter", 9));
+        ASSERT_EQ(0xdeadbeef, resp->v.v0.value);
+    }
+}
+
+/**
+ * Common function to bootstrap an arithmetic key and set the expected/last
+ * value counter.
+ */
+static void initArithmeticKey(lcb_t instance, std::string key,
+                              lcb_uint64_t value)
+{
+    std::stringstream ss;
+    ss << value;
+    storeKey(instance, key, ss.str());
+    arithm_val = value;
+}
+
+/**
+ * @test Arithmetic (incr)
+ * @pre initialize a global variable @c arithm_val to 0.
+ * Schedule 10 arithmetic operations. The arithmetic callback should check
+ * that the current value is one greater than @c arithm_val. Then set
+ * @c arithm_val to the current value.
+ *
+ * @post The callback's assertions succeed (see precondition)
+ */
+TEST_F(ArithmeticUnitTest, testIncr)
+{
+    lcb_t instance;
+    HandleWrap hw;
+    createConnection(hw, instance);
+    (void)lcb_set_arithmetic_callback(instance, arithmetic_incr_callback);
+
+    initArithmeticKey(instance, "counter", 0);
+
+    for (int ii = 0; ii < 10; ++ii) {
+        lcb_arithmetic_cmd_t cmd("counter", 7, 1);
+        lcb_arithmetic_cmd_t *cmds[] = { &cmd };
+        lcb_arithmetic(instance, NULL, 1, cmds);
+        lcb_wait(instance);
+    }
+}
+
+/**
+ * @test Arithmetic (Decr)
+ *
+ * @pre Initialize the @c arithm_val to @c 100. Decrement the key 10 times.
+ *
+ * @post See @ref testIncr for expectations
+ */
+TEST_F(ArithmeticUnitTest, testDecr)
+{
+    lcb_t instance;
+    HandleWrap hw;
+    createConnection(hw, instance);
+    (void)lcb_set_arithmetic_callback(instance, arithmetic_decr_callback);
+
+    initArithmeticKey(instance, "counter", 100);
+
+    for (int ii = 0; ii < 10; ++ii) {
+        lcb_arithmetic_cmd_t cmd("counter", 7, -1);
+        lcb_arithmetic_cmd_t *cmds[] = { &cmd };
+        lcb_arithmetic(instance, NULL, 1, cmds);
+        lcb_wait(instance);
+    }
+
+}
+
+/**
+ * @test Arithmetic (Creation)
+ * @pre Perform an arithmetic operation on a non-existent key. The increment
+ * offset is @c 0x77 and the default value is @c 0xdeadbeef
+ *
+ * @post Value upon getting the key is @c 0xdeadbeef
+ */
+TEST_F(ArithmeticUnitTest, testArithmeticCreate)
+{
+    lcb_t instance;
+    HandleWrap hw;
+    createConnection(hw, instance);
+
+    removeKey(instance, "mycounter");
+    (void)lcb_set_arithmetic_callback(instance, arithmetic_create_callback);
+    lcb_arithmetic_cmd_t cmd("mycounter", 9, 0x77, 1, 0xdeadbeef);
+    lcb_arithmetic_cmd_t *cmds[] = { &cmd };
+    lcb_arithmetic(instance, NULL, 1, cmds);
+    lcb_wait(instance);
+}

data/ext/libcouchbase/tests/iotests/t_behavior.cc

@@ -0,0 +1,220 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012 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 "config.h"
+#include <gtest/gtest.h>
+#include <libcouchbase/couchbase.h>
+#include <map>
+
+#define ENV_VAR_NAME "LCB_IOPS_NAME"
+#define ENV_VAR_SYM "LCB_IOPS_SYMBOL"
+
+
+#ifdef _WIN32
+#define EXPECTED_DEFAULT LCB_IO_OPS_WINIOCP
+#define EXPECTED_EFFECTIVE EXPECTED_DEFAULT
+#define setenv(k, v, o) SetEnvironmentVariable(k, v)
+#else
+#define EXPECTED_DEFAULT LCB_IO_OPS_LIBEVENT
+#if defined(HAVE_LIBEVENT) || defined(HAVE_LIBEVENT2)
+#define EXPECTED_EFFECTIVE EXPECTED_DEFAULT
+#else
+#define EXPECTED_EFFECTIVE LCB_IO_OPS_SELECT
+#endif
+#endif
+
+static void setPluginEnv(const std::string &name, const std::string &sym)
+{
+    setenv(ENV_VAR_NAME, name.c_str(), 1);
+    setenv(ENV_VAR_SYM, sym.c_str(), 1);
+}
+
+static void clearPluginEnv()
+{
+    setPluginEnv("", "");
+}
+
+typedef std::map<std::string, lcb_io_ops_type_t> plugin_map;
+class PluginMap
+{
+public:
+    plugin_map kv;
+
+    PluginMap() {
+        kv["select"] = LCB_IO_OPS_SELECT;
+        kv["libevent"] = LCB_IO_OPS_LIBEVENT;
+        kv["libev"] = LCB_IO_OPS_LIBEV;
+#ifdef _WIN32
+        kv["iocp"] = LCB_IO_OPS_WINIOCP;
+        kv["winsock"] = LCB_IO_OPS_WINSOCK;
+#endif
+    }
+
+};
+
+static PluginMap plugins;
+
+class Behavior : public ::testing::Test
+{
+public:
+    virtual void SetUp() {
+        const char *tmp;
+        if ((tmp = getenv(ENV_VAR_NAME)) != NULL) {
+            origPluginName = tmp;
+        }
+
+        if ((tmp = getenv(ENV_VAR_SYM)) != NULL) {
+            origPluginSymbol = tmp;
+        }
+
+        // Clear it
+        clearPluginEnv();
+
+        ASSERT_EQ(LCB_SUCCESS, lcb_create(&instance, NULL));
+    }
+
+    virtual void TearDown() {
+        lcb_destroy(instance);
+        setPluginEnv(origPluginName, origPluginSymbol);
+    }
+
+protected:
+    lcb_t instance;
+    std::string origPluginName;
+    std::string origPluginSymbol;
+};
+
+
+TEST_F(Behavior, CheckDefaultValues)
+{
+    lcb_ipv6_t val;
+    lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_IP6POLICY, &val);
+    EXPECT_EQ(LCB_IPV6_DISABLED, val);
+    return;
+}
+
+TEST_F(Behavior, CheckIPv6)
+{
+    lcb_ipv6_t val = LCB_IPV6_ONLY;
+    lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_IP6POLICY, &val);
+    lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_IP6POLICY, &val);
+    EXPECT_EQ(LCB_IPV6_ONLY, val);
+
+    val = LCB_IPV6_ALLOW;
+    lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_IP6POLICY, &val);
+    lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_IP6POLICY, &val);
+    ASSERT_EQ(LCB_IPV6_ALLOW, val);
+
+    val = LCB_IPV6_DISABLED;
+    lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_IP6POLICY, &val);
+    lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_IP6POLICY, &val);
+    ASSERT_EQ(LCB_IPV6_DISABLED, val);
+}
+
+TEST_F(Behavior, PluginDefaults)
+{
+    lcb_error_t err;
+    struct lcb_cntl_iops_info_st info;
+    memset(&info, 0, sizeof(info));
+
+    err = lcb_cntl(NULL, LCB_CNTL_GET, LCB_CNTL_IOPS_DEFAULT_TYPES, &info);
+
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_EQ(EXPECTED_DEFAULT, info.v.v0.os_default);
+    ASSERT_EQ(EXPECTED_EFFECTIVE, info.v.v0.effective);
+}
+
+TEST_F(Behavior, PluginEnvironment)
+{
+
+    for (plugin_map::iterator iter = plugins.kv.begin();
+            iter != plugins.kv.end(); iter++) {
+
+        setPluginEnv(iter->first, "");
+
+        lcb_error_t err;
+        struct lcb_cntl_iops_info_st info;
+        memset(&info, 0, sizeof(info));
+
+        err = lcb_cntl(NULL, LCB_CNTL_GET, LCB_CNTL_IOPS_DEFAULT_TYPES, &info);
+        ASSERT_EQ(LCB_SUCCESS, err);
+        ASSERT_EQ(EXPECTED_DEFAULT, info.v.v0.os_default);
+        ASSERT_EQ(iter->second, info.v.v0.effective) << iter->first;
+    }
+}
+
+TEST_F(Behavior, PluginOverrides)
+{
+    // Environment is cleared
+    struct lcb_create_io_ops_st options;
+    struct lcb_cntl_iops_info_st ioinfo;
+
+    memset(&options, 0, sizeof(options));
+    memset(&ioinfo, 0, sizeof(ioinfo));
+
+    setPluginEnv("select", "");
+    options.version = 0;
+    options.v.v0.type = LCB_IO_OPS_LIBEV;
+    lcb_error_t err;
+
+    ioinfo.v.v0.options = &options;
+    err = lcb_cntl(NULL, LCB_CNTL_GET, LCB_CNTL_IOPS_DEFAULT_TYPES, &ioinfo);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_EQ(ioinfo.v.v0.effective, LCB_IO_OPS_LIBEV);
+
+    setPluginEnv("select", "");
+    options.v.v0.type = LCB_IO_OPS_DEFAULT;
+    err = lcb_cntl(NULL, LCB_CNTL_GET, LCB_CNTL_IOPS_DEFAULT_TYPES, &ioinfo);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_EQ(ioinfo.v.v0.effective, LCB_IO_OPS_SELECT);
+
+    memset(&options, 0, sizeof(options));
+    options.version = 1;
+    options.v.v1.sofile = "libfoo";
+    options.v.v1.symbol = "abort";
+    err = lcb_cntl(NULL, LCB_CNTL_GET, LCB_CNTL_IOPS_DEFAULT_TYPES, &ioinfo);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_EQ(ioinfo.v.v0.effective, 0);
+
+}
+
+TEST_F(Behavior, BadPluginEnvironment)
+{
+    lcb_error_t err;
+    struct lcb_cntl_iops_info_st info;
+    memset(&info, 0, sizeof(info));
+
+    setPluginEnv("foobarbaz", "non_existent_symbol");
+    err = lcb_cntl(NULL, LCB_CNTL_GET, LCB_CNTL_IOPS_DEFAULT_TYPES, &info);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_EQ(EXPECTED_DEFAULT, info.v.v0.os_default);
+    ASSERT_EQ(0, info.v.v0.effective);
+
+    lcb_t instance2;
+    ASSERT_EQ(LCB_DLOPEN_FAILED, lcb_create(&instance2, NULL));
+
+    setPluginEnv("foobarbaz", "");
+    ASSERT_EQ(LCB_BAD_ENVIRONMENT, lcb_create(&instance2, NULL));
+
+    // Find a DLL that we know can be loaded, but doesn't have the symbols
+    // we need. For windows, we use the unqualified name,
+    const char *dllname = TEST_SHARED_OBJECT;
+
+    setPluginEnv(dllname, "nonexist-symbol");
+    ASSERT_EQ(LCB_DLSYM_FAILED, lcb_create(&instance2, NULL));
+
+}

data/ext/libcouchbase/tests/iotests/t_configcache.cc

@@ -0,0 +1,117 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2012 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 "config.h"
+#include "iotests.h"
+
+#include <cstdio>
+
+class ConfigCacheUnitTest : public MockUnitTest
+{
+};
+
+extern "C" {
+static void bootstrap_callback(lcb_t instance, lcb_error_t err)
+{
+    EXPECT_EQ(LCB_SUCCESS, err);
+    int *pp = (int *)lcb_get_cookie(instance);
+    *pp += 1;
+}
+}
+
+TEST_F(ConfigCacheUnitTest, testConfigCache)
+{
+    lcb_t instance;
+    lcb_error_t err;
+    lcb_create_st cropts;
+
+    // Get the filename:
+    char filename[L_tmpnam + 0];
+    ASSERT_TRUE(NULL != tmpnam(filename));
+    memset(&cropts, 0, sizeof(cropts));
+
+    MockEnvironment::getInstance()->makeConnectParams(cropts, NULL);
+    doLcbCreate(&instance, &cropts, MockEnvironment::getInstance());
+    err = lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_CONFIGCACHE, (void *)filename);
+    ASSERT_EQ(LCB_SUCCESS, err);
+
+    int is_loaded;
+    err = lcb_cntl(instance, LCB_CNTL_GET,
+                   LCB_CNTL_CONFIG_CACHE_LOADED, &is_loaded);
+
+    ASSERT_EQ(err, LCB_SUCCESS);
+    ASSERT_EQ(is_loaded, 0);
+
+    err = lcb_connect(instance);
+    ASSERT_EQ(err, LCB_SUCCESS);
+
+    err = lcb_wait(instance);
+    ASSERT_EQ(err, LCB_SUCCESS);
+
+    // now try another one
+    lcb_destroy(instance);
+    doLcbCreate(&instance, &cropts, MockEnvironment::getInstance());
+    ASSERT_EQ(LCB_SUCCESS, err);
+    err = lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_CONFIGCACHE, (void *)filename);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    lcb_set_bootstrap_callback(instance, bootstrap_callback);
+    int bsCalled = 0;
+    lcb_set_cookie(instance, &bsCalled);
+
+    err = lcb_connect(instance);
+    ASSERT_EQ(LCB_SUCCESS, err);
+
+    err = lcb_wait(instance);
+    ASSERT_EQ(LCB_SUCCESS, err);
+
+    err = lcb_cntl(instance, LCB_CNTL_GET,
+                   LCB_CNTL_CONFIG_CACHE_LOADED, &is_loaded);
+    ASSERT_NE(0, is_loaded);
+    ASSERT_EQ(1, bsCalled);
+
+    /* Just make sure we can schedule a command */
+    storeKey(instance, "a_key", "a_value");
+
+    lcb_destroy(instance);
+
+    doLcbCreate(&instance, &cropts, MockEnvironment::getInstance());
+    ASSERT_EQ(LCB_SUCCESS, err);
+    err = lcb_cntl_string(instance, "config_cache", filename);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    err = lcb_connect(instance);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    lcb_wait(instance);
+    err = lcb_cntl(instance, LCB_CNTL_GET, LCB_CNTL_CONFIG_CACHE_LOADED, &is_loaded);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_NE(0, is_loaded);
+    lcb_destroy(instance);
+
+    doLcbCreate(&instance, &cropts, MockEnvironment::getInstance());
+    ASSERT_EQ(LCB_SUCCESS, err);
+    err = lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_CONFIGCACHE_RO, (void *)filename);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    lcb_destroy(instance);
+
+    remove(filename);
+
+    // Try one more time, with a file that does not exist..
+    doLcbCreate(&instance, &cropts, MockEnvironment::getInstance());
+    ASSERT_EQ(LCB_SUCCESS, err);
+    err = lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_CONFIGCACHE_RO, (void *)filename);
+    ASSERT_NE(LCB_SUCCESS, err);
+    lcb_destroy(instance);
+}

data/ext/libcouchbase/tests/iotests/t_confmon.cc

@@ -0,0 +1,223 @@
+#define LCB_BOOTSTRAP_DEFINE_STRUCT
+
+#include "iotests.h"
+#include "config.h"
+#include "internal.h"
+#include "bucketconfig/clconfig.h"
+#include <lcbio/iotable.h>
+#include <set>
+
+using namespace lcb::clconfig;
+
+class ConfmonTest : public ::testing::Test
+{
+    void SetUp() {
+        MockEnvironment::Reset();
+    }
+};
+
+struct evstop_listener : Listener {
+    lcbio_pTABLE io;
+    int called;
+
+    void clconfig_lsn(EventType event, ConfigInfo*) {
+        if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
+            return;
+        }
+        called = 1;
+        IOT_STOP(io);
+    }
+
+    evstop_listener() : Listener(), io(NULL), called(0) {
+    }
+};
+
+extern "C" {
+static void listen_callback1(Listener *lsn, EventType event,
+                             ConfigInfo *info)
+{
+}
+}
+
+TEST_F(ConfmonTest, testBasic)
+{
+    HandleWrap hw;
+    lcb_t instance;
+    MockEnvironment::getInstance()->createConnection(hw, instance);
+
+
+    Confmon *mon = new Confmon(instance->settings, instance->iotable, instance);
+    Provider *http = mon->get_provider(CLCONFIG_HTTP);
+    http->enable();
+    http->configure_nodes(*instance->ht_nodes);
+
+    mon->prepare();
+
+    EXPECT_EQ(NULL, mon->get_config());
+    mon->start();
+    mon->start(); // Twice!
+    mon->stop();
+    mon->stop();
+
+    // Try to find a provider..
+    Provider *provider = mon->get_provider(CLCONFIG_HTTP);
+    ASSERT_NE(0, provider->enabled);
+
+    evstop_listener listener;
+    listener.io = instance->iotable;
+    mon->add_listener(&listener);
+    mon->start();
+    IOT_START(instance->iotable);
+    ASSERT_NE(0, listener.called);
+    delete mon;
+}
+
+
+struct listener2 : Listener {
+    int call_count;
+    lcbio_pTABLE io;
+    Method last_source;
+    std::set<EventType> expected_events;
+
+    void reset() {
+        call_count = 0;
+        last_source = CLCONFIG_PHONY;
+        expected_events.clear();
+    }
+
+    listener2() : Listener() {
+        io = NULL;
+        reset();
+    }
+
+    void clconfig_lsn(EventType event, ConfigInfo *info) {
+        if (event == CLCONFIG_EVENT_MONITOR_STOPPED) {
+            IOT_START(io);
+            return;
+        }
+
+        if (!expected_events.empty()) {
+            if (expected_events.end() ==
+                expected_events.find(event)) {
+                return;
+            }
+        }
+
+        call_count++;
+        last_source = info->get_origin();
+        IOT_STOP(io);
+
+    }
+};
+
+static void runConfmonTest(lcbio_pTABLE io, Confmon *mon)
+{
+    IOT_START(io);
+}
+
+TEST_F(ConfmonTest, testCycle)
+{
+    HandleWrap hw;
+    lcb_t instance;
+    lcb_create_st cropts;
+    MockEnvironment *mock = MockEnvironment::getInstance();
+
+    if (mock->isRealCluster()) {
+        return;
+    }
+
+    mock->createConnection(hw, instance);
+    instance->settings->bc_http_stream_time = 100000;
+    instance->memd_sockpool->get_options().tmoidle = 100000;
+
+    Confmon *mon = new Confmon(instance->settings, instance->iotable, instance);
+
+    struct listener2 lsn;
+    lsn.io = instance->iotable;
+    lsn.reset();
+    mon->add_listener(&lsn);
+
+    mock->makeConnectParams(cropts, NULL);
+    Provider *cccp = mon->get_provider(CLCONFIG_CCCP);
+    Provider *http = mon->get_provider(CLCONFIG_HTTP);
+
+    lcb::Hostlist hl;
+    hl.add(cropts.v.v2.mchosts, 11210);
+    cccp->enable(instance);
+    cccp->configure_nodes(hl);
+
+    http->enable();
+    http->configure_nodes(*instance->ht_nodes);
+
+    mon->prepare();
+    mon->start();
+    lsn.expected_events.insert(CLCONFIG_EVENT_GOT_NEW_CONFIG);
+    runConfmonTest(lsn.io, mon);
+
+    // Ensure CCCP is functioning properly and we're called only once.
+    ASSERT_EQ(1, lsn.call_count);
+    ASSERT_EQ(CLCONFIG_CCCP, lsn.last_source);
+
+    mon->start();
+    lsn.reset();
+    lsn.expected_events.insert(CLCONFIG_EVENT_GOT_ANY_CONFIG);
+    runConfmonTest(lsn.io, mon);
+    ASSERT_EQ(1, lsn.call_count);
+    ASSERT_EQ(CLCONFIG_CCCP, lsn.last_source);
+
+    mock->setCCCP(false);
+    mock->failoverNode(5);
+    lsn.reset();
+    mon->start();
+    lsn.expected_events.insert(CLCONFIG_EVENT_GOT_ANY_CONFIG);
+    lsn.expected_events.insert(CLCONFIG_EVENT_GOT_NEW_CONFIG);
+    runConfmonTest(lsn.io, mon);
+    ASSERT_EQ(CLCONFIG_HTTP, lsn.last_source);
+    ASSERT_EQ(1, lsn.call_count);
+    delete mon;
+}
+
+TEST_F(ConfmonTest, testBootstrapMethods)
+{
+    lcb_t instance;
+    HandleWrap hw;
+    MockEnvironment::getInstance()->createConnection(hw, instance);
+    lcb_error_t err = lcb_connect(instance);
+    ASSERT_EQ(LCB_SUCCESS, err);
+
+    // Try the various bootstrap times
+    lcb::Bootstrap* bs = instance->bs_state;
+    hrtime_t last = bs->get_last_refresh(), cur = 0;
+
+    // Reset it for the time being
+    bs->reset_last_refresh();
+    instance->confmon->stop();
+
+    // Refreshing now should work
+    instance->bootstrap(lcb::BS_REFRESH_THROTTLE);
+    ASSERT_TRUE(instance->confmon->is_refreshing());
+
+    cur = bs->get_last_refresh();
+    ASSERT_GT(cur, 0);
+    ASSERT_EQ(0, bs->get_errcounter());
+    last = cur;
+
+    // Stop it, so the state is reset
+    instance->confmon->stop();
+    ASSERT_FALSE(instance->confmon->is_refreshing());
+
+    instance->bootstrap(lcb::BS_REFRESH_THROTTLE|lcb::BS_REFRESH_INCRERR);
+    ASSERT_EQ(last, bs->get_last_refresh());
+    ASSERT_EQ(1, bs->get_errcounter());
+
+    // Ensure that a throttled-without-incr doesn't actually incr
+    instance->bootstrap(lcb::BS_REFRESH_THROTTLE);
+    ASSERT_EQ(1, bs->get_errcounter());
+
+    // No refresh yet
+    ASSERT_FALSE(instance->confmon->is_refreshing());
+
+    instance->bootstrap(lcb::BS_REFRESH_ALWAYS);
+    ASSERT_TRUE(instance->confmon->is_refreshing());
+    instance->confmon->stop();
+}