libcouchbase 0.3.3 → 1.0.0

data/ext/libcouchbase/tests/iotests/mock-environment.cc

@@ -112,7 +112,7 @@ std::vector<int> MockEnvironment::getMcPorts(std::string bucket)
 
     std::vector<int> ret;
 
-    for (int ii = 0; ii < payload.size(); ii++) {
+    for (int ii = 0; ii < (int)payload.size(); ii++) {
         ret.push_back(payload[ii].asInt());
     }
     return ret;
@@ -143,6 +143,31 @@ void MockEnvironment::setCCCP(bool enabled, std::string bucket,
     getResponse();
 }
 
+void MockEnvironment::setEnhancedErrors(bool enabled, std::string bucket,
+                                        const std::vector<int>* nodes)
+{
+    MockCommand cmd(MockCommand::SET_ENHANCED_ERRORS);
+    cmd.set("enabled", enabled);
+
+    if (!bucket.empty()) {
+        cmd.set("bucket", bucket);
+    }
+
+    if (nodes != NULL) {
+        const std::vector<int>& v = *nodes;
+        Json::Value array(Json::arrayValue);
+
+        for (std::vector<int>::const_iterator ii = v.begin(); ii != v.end(); ii++) {
+            array.append(*ii);
+        }
+
+        cmd.set("servers", array);
+    }
+
+    sendCommand(cmd);
+    getResponse();
+}
+
 void MockEnvironment::sendCommand(MockCommand &cmd)
 {
     std::string s = cmd.encode();
@@ -166,6 +191,7 @@ void MockEnvironment::getResponse(MockResponse& ret)
     ret.assign(rbuf);
     if (!ret.isOk()) {
         std::cerr << "Mock command failed!" << std::endl;
+        std::cerr << ret.constResp()["error"].asString() << std::endl;
         std::cerr << ret;
     }
 }
@@ -386,7 +412,7 @@ void MockEnvironment::SetUp()
     }
     serverParams = ServerParams(http,
                                 bucketName.c_str(),
-                                bucketName.c_str(),
+                                userName.c_str(),
                                 NULL);
 
     // Mock 0.6

data/ext/libcouchbase/tests/iotests/mock-environment.h

@@ -71,7 +71,11 @@ class MockCommand
     X(GET_MCPORTS) \
     X(SET_CCCP) \
     X(REGEN_VBCOORDS) \
-    X(RESET_QUERYSTATE)
+    X(RESET_QUERYSTATE) \
+    X(OPFAIL) \
+    X(START_RETRY_VERIFY) \
+    X(CHECK_RETRY_VERIFY) \
+    X(SET_ENHANCED_ERRORS)
 
 public:
     enum Code {
@@ -164,6 +168,38 @@ protected:
     std::string bucket;
 };
 
+class MockOpfailCommand : public MockCommand
+{
+public:
+    MockOpfailCommand(uint16_t errcode, int index, int count = -1,
+                      std::string bucketstr = "default")
+        : MockCommand(OPFAIL) {
+        set("count", count);
+        set("bucket", bucketstr);
+        set("code", errcode);
+
+        Json::Value srvlist(Json::arrayValue);
+        srvlist.append(index);
+        set("servers", srvlist);
+    }
+};
+
+class MockOpFailClearCommand : public MockCommand {
+public:
+    MockOpFailClearCommand(size_t nservers, std::string bucketstr = "default")
+        : MockCommand(OPFAIL) {
+        set("count", -1);
+        set("bucket", bucketstr);
+        set("code", 0);
+
+        Json::Value srvlist(Json::arrayValue);
+        for (size_t ii = 0; ii < nservers; ++ii) {
+            srvlist.append(static_cast<int>(ii));
+        }
+        set("servers", srvlist);
+    }
+};
+
 class MockResponse
 {
 public:
@@ -277,6 +313,19 @@ public:
                  std::string bucket = "",
                  const std::vector<int>* nodes = NULL);
 
+    /**
+     * Enable enhanced errors on the mock cluster
+     *
+     * This includes generation event id (ref), and setting context for some errors
+     * .
+     * @param bucket the bucket on which to enable enhanced errors
+     * @param nodes a list of by-index nodes on which to enable Enhanced Errors. If NULL
+     * then all nodes are enabled
+     */
+    void setEnhancedErrors(bool enabled,
+                           std::string bucket = "",
+                           const std::vector<int>* nodes = NULL);
+
     /**
      * Create a connection to the mock/real server.
      *
@@ -352,6 +401,7 @@ protected:
     lcb_io_opt_st *iops;
     std::set<std::string> featureRegistry;
     std::string bucketName;
+    std::string userName;
     const char **argv;
     void clearAndReset();
 

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

@@ -212,13 +212,7 @@ TEST_F(Behavior, BadPluginEnvironment)
 
     // Find a DLL that we know can be loaded, but doesn't have the symbols
     // we need. For windows, we use the unqualified name,
-#ifdef _WIN32
-    const char *dllname = "kernel32.dll.";
-#elif __APPLE__
-    const char *dllname = "libm.dylib";
-#else
-    const char *dllname = "libm.so";
-#endif
+    const char *dllname = TEST_SHARED_OBJECT;
 
     setPluginEnv(dllname, "nonexist-symbol");
     ASSERT_EQ(lcb_create(&instance2, NULL), LCB_DLSYM_FAILED);

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

@@ -7,130 +7,115 @@
 #include <lcbio/iotable.h>
 #include <set>
 
-class Confmon : public ::testing::Test
+using namespace lcb::clconfig;
+
+class ConfmonTest : public ::testing::Test
 {
     void SetUp() {
         MockEnvironment::Reset();
     }
 };
 
-struct evstop_listener {
-    clconfig_listener base;
+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(clconfig_listener *lsn, clconfig_event_t event,
-                             clconfig_info *info)
+static void listen_callback1(Listener *lsn, EventType event,
+                             ConfigInfo *info)
 {
-    if (event != CLCONFIG_EVENT_GOT_NEW_CONFIG) {
-        return;
-    }
-
-    evstop_listener *me = reinterpret_cast<evstop_listener*>(lsn);
-    me->called = 1;
-    IOT_STOP(me->io);
 }
 }
 
-TEST_F(Confmon, testBasic)
+TEST_F(ConfmonTest, testBasic)
 {
     HandleWrap hw;
     lcb_t instance;
     MockEnvironment::getInstance()->createConnection(hw, instance);
 
 
-    lcb_confmon *mon = lcb_confmon_create(instance->settings, instance->iotable);
-    clconfig_provider *http = lcb_confmon_get_provider(mon, LCB_CLCONFIG_HTTP);
-    lcb_clconfig_http_enable(http);
-    lcb_clconfig_http_set_nodes(http, instance->ht_nodes);
+    Confmon *mon = new Confmon(instance->settings, instance->iotable);
+    Provider *http = mon->get_provider(CLCONFIG_HTTP);
+    http->enable();
+    http->configure_nodes(*instance->ht_nodes);
 
-    lcb_confmon_prepare(mon);
+    mon->prepare();
 
-    EXPECT_EQ(NULL, lcb_confmon_get_config(mon));
-    EXPECT_EQ(LCB_SUCCESS, lcb_confmon_start(mon));
-    EXPECT_EQ(LCB_SUCCESS, lcb_confmon_start(mon));
-    EXPECT_EQ(LCB_SUCCESS, lcb_confmon_stop(mon));
-    EXPECT_EQ(LCB_SUCCESS, lcb_confmon_stop(mon));
+    EXPECT_EQ(NULL, mon->get_config());
+    mon->start();
+    mon->start(); // Twice!
+    mon->stop();
+    mon->stop();
 
     // Try to find a provider..
-    clconfig_provider *provider = lcb_confmon_get_provider(mon, LCB_CLCONFIG_HTTP);
+    Provider *provider = mon->get_provider(CLCONFIG_HTTP);
     ASSERT_NE(0, provider->enabled);
 
-    struct evstop_listener listener;
-    memset(&listener, 0, sizeof(listener));
-
-    listener.base.callback = listen_callback1;
-    listener.base.parent = mon;
+    evstop_listener listener;
     listener.io = instance->iotable;
-
-    lcb_confmon_add_listener(mon, &listener.base);
-    lcb_confmon_start(mon);
+    mon->add_listener(&listener);
+    mon->start();
     IOT_START(instance->iotable);
     ASSERT_NE(0, listener.called);
-
-    lcb_confmon_destroy(mon);
+    delete mon;
 }
 
 
-struct listener2 {
-    clconfig_listener base;
+struct listener2 : Listener {
     int call_count;
     lcbio_pTABLE io;
-    clconfig_method_t last_source;
-    std::set<clconfig_event_t> expected_events;
+    Method last_source;
+    std::set<EventType> expected_events;
 
     void reset() {
         call_count = 0;
-        last_source = LCB_CLCONFIG_PHONY;
+        last_source = CLCONFIG_PHONY;
         expected_events.clear();
     }
 
-    listener2() {
-        memset(&base, 0, sizeof(base));
+    listener2() : Listener() {
         io = NULL;
         reset();
     }
-};
 
-static struct listener2* getListener2(const void *p)
-{
-    return reinterpret_cast<struct listener2*>(const_cast<void*>(p));
-}
+    void clconfig_lsn(EventType event, ConfigInfo *info) {
+        if (event == CLCONFIG_EVENT_MONITOR_STOPPED) {
+            IOT_START(io);
+            return;
+        }
 
-extern "C" {
-static void listen_callback2(clconfig_listener *prov,
-                             clconfig_event_t event,
-                             clconfig_info *info)
-{
-    // Increase the number of times we've received a callback..
-    struct listener2* lsn = getListener2(prov);
+        if (!expected_events.empty()) {
+            if (expected_events.end() ==
+                expected_events.find(event)) {
+                return;
+            }
+        }
 
-    if (event == CLCONFIG_EVENT_MONITOR_STOPPED) {
-        IOT_START(lsn->io);
-        return;
-    }
+        call_count++;
+        last_source = info->get_origin();
+        IOT_STOP(io);
 
-    if (!lsn->expected_events.empty()) {
-        if (lsn->expected_events.end() ==
-            lsn->expected_events.find(event)) {
-            return;
-        }
     }
+};
 
-    lsn->call_count++;
-    lsn->last_source = info->origin;
-    IOT_STOP(lsn->io);
-}
-}
-
-static void runConfmon(lcbio_pTABLE io, lcb_confmon *mon)
+static void runConfmonTest(lcbio_pTABLE io, Confmon *mon)
 {
     IOT_START(io);
 }
 
-TEST_F(Confmon, testCycle)
+TEST_F(ConfmonTest, testCycle)
 {
     HandleWrap hw;
     lcb_t instance;
@@ -143,59 +128,56 @@ TEST_F(Confmon, testCycle)
 
     mock->createConnection(hw, instance);
     instance->settings->bc_http_stream_time = 100000;
-    instance->memd_sockpool->tmoidle = 100000;
+    instance->memd_sockpool->get_options().tmoidle = 100000;
 
-    lcb_confmon *mon = lcb_confmon_create(instance->settings, instance->iotable);
+    Confmon *mon = new Confmon(instance->settings, instance->iotable);
 
     struct listener2 lsn;
-    lsn.base.callback = listen_callback2;
     lsn.io = instance->iotable;
     lsn.reset();
-
-    lcb_confmon_add_listener(mon, &lsn.base);
+    mon->add_listener(&lsn);
 
     mock->makeConnectParams(cropts, NULL);
-    clconfig_provider *cccp = lcb_confmon_get_provider(mon, LCB_CLCONFIG_CCCP);
-    clconfig_provider *http = lcb_confmon_get_provider(mon, LCB_CLCONFIG_HTTP);
+    Provider *cccp = mon->get_provider(CLCONFIG_CCCP);
+    Provider *http = mon->get_provider(CLCONFIG_HTTP);
 
-    hostlist_t hl = hostlist_create();
-    hostlist_add_stringz(hl, cropts.v.v2.mchosts, 11210);
-    lcb_clconfig_cccp_enable(cccp, instance);
-    lcb_clconfig_cccp_set_nodes(cccp, hl);
+    lcb::Hostlist hl;
+    hl.add(cropts.v.v2.mchosts, 11210);
+    cccp->enable(instance);
+    cccp->configure_nodes(hl);
 
-    lcb_clconfig_http_enable(http);
-    lcb_clconfig_http_set_nodes(http, instance->ht_nodes);
-    hostlist_destroy(hl);
+    http->enable();
+    http->configure_nodes(*instance->ht_nodes);
 
-    lcb_confmon_prepare(mon);
-    lcb_confmon_start(mon);
+    mon->prepare();
+    mon->start();
     lsn.expected_events.insert(CLCONFIG_EVENT_GOT_NEW_CONFIG);
-    runConfmon(lsn.io, mon);
+    runConfmonTest(lsn.io, mon);
 
     // Ensure CCCP is functioning properly and we're called only once.
     ASSERT_EQ(1, lsn.call_count);
-    ASSERT_EQ(LCB_CLCONFIG_CCCP, lsn.last_source);
+    ASSERT_EQ(CLCONFIG_CCCP, lsn.last_source);
 
-    lcb_confmon_start(mon);
+    mon->start();
     lsn.reset();
     lsn.expected_events.insert(CLCONFIG_EVENT_GOT_ANY_CONFIG);
-    runConfmon(lsn.io, mon);
+    runConfmonTest(lsn.io, mon);
     ASSERT_EQ(1, lsn.call_count);
-    ASSERT_EQ(LCB_CLCONFIG_CCCP, lsn.last_source);
+    ASSERT_EQ(CLCONFIG_CCCP, lsn.last_source);
 
     mock->setCCCP(false);
     mock->failoverNode(5);
     lsn.reset();
-    lcb_confmon_start(mon);
+    mon->start();
     lsn.expected_events.insert(CLCONFIG_EVENT_GOT_ANY_CONFIG);
     lsn.expected_events.insert(CLCONFIG_EVENT_GOT_NEW_CONFIG);
-    runConfmon(lsn.io, mon);
-    ASSERT_EQ(LCB_CLCONFIG_HTTP, lsn.last_source);
+    runConfmonTest(lsn.io, mon);
+    ASSERT_EQ(CLCONFIG_HTTP, lsn.last_source);
     ASSERT_EQ(1, lsn.call_count);
-    lcb_confmon_destroy(mon);
+    delete mon;
 }
 
-TEST_F(Confmon, testBootstrapMethods)
+TEST_F(ConfmonTest, testBootstrapMethods)
 {
     lcb_t instance;
     HandleWrap hw;
@@ -204,38 +186,38 @@ TEST_F(Confmon, testBootstrapMethods)
     ASSERT_EQ(LCB_SUCCESS, err);
 
     // Try the various bootstrap times
-    struct lcb_BOOTSTRAP *bs = instance->bootstrap;
-    hrtime_t last = bs->last_refresh, cur = 0;
+    lcb::Bootstrap* bs = instance->bs_state;
+    hrtime_t last = bs->get_last_refresh(), cur = 0;
 
     // Reset it for the time being
-    bs->last_refresh = 0;
-    lcb_confmon_stop(instance->confmon);
+    bs->reset_last_refresh();
+    instance->confmon->stop();
 
     // Refreshing now should work
-    lcb_bootstrap_common(instance, LCB_BS_REFRESH_THROTTLE);
-    ASSERT_NE(0, lcb_confmon_is_refreshing(instance->confmon));
+    instance->bootstrap(lcb::BS_REFRESH_THROTTLE);
+    ASSERT_TRUE(instance->confmon->is_refreshing());
 
-    cur = bs->last_refresh;
+    cur = bs->get_last_refresh();
     ASSERT_GT(cur, 0);
-    ASSERT_EQ(0, bs->errcounter);
+    ASSERT_EQ(0, bs->get_errcounter());
     last = cur;
 
     // Stop it, so the state is reset
-    lcb_confmon_stop(instance->confmon);
-    ASSERT_EQ(0, lcb_confmon_is_refreshing(instance->confmon));
+    instance->confmon->stop();
+    ASSERT_FALSE(instance->confmon->is_refreshing());
 
-    lcb_bootstrap_common(instance, LCB_BS_REFRESH_THROTTLE|LCB_BS_REFRESH_INCRERR);
-    ASSERT_EQ(last, bs->last_refresh);
-    ASSERT_EQ(1, bs->errcounter);
+    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
-    lcb_bootstrap_common(instance, LCB_BS_REFRESH_THROTTLE);
-    ASSERT_EQ(1, bs->errcounter);
+    instance->bootstrap(lcb::BS_REFRESH_THROTTLE);
+    ASSERT_EQ(1, bs->get_errcounter());
 
     // No refresh yet
-    ASSERT_EQ(0, lcb_confmon_is_refreshing(instance->confmon));
+    ASSERT_FALSE(instance->confmon->is_refreshing());
 
-    lcb_bootstrap_common(instance, LCB_BS_REFRESH_ALWAYS);
-    ASSERT_NE(0, lcb_confmon_is_refreshing(instance->confmon));
-    lcb_confmon_stop(instance->confmon);
+    instance->bootstrap(lcb::BS_REFRESH_ALWAYS);
+    ASSERT_TRUE(instance->confmon->is_refreshing());
+    instance->confmon->stop();
 }