libcouchbase 0.0.1

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

@@ -0,0 +1,88 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2016 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 <libcouchbase/couchbase.h>
+#include <map>
+#include "iotests.h"
+#include "internal.h"
+
+class SchedUnitTests : public MockUnitTest
+{
+};
+
+static bool
+hasPendingOps(lcb_t instance)
+{
+    for (size_t ii = 0; ii < LCBT_NSERVERS(instance); ++ii) {
+        mc_SERVER *ss = LCBT_GET_SERVER(instance, ii);
+        if (mcserver_has_pending(ss)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static void
+opCallback(lcb_t, int, const lcb_RESPBASE *rb) {
+    size_t *counter = reinterpret_cast<size_t*>(rb->cookie);
+    *counter += 1;
+}
+
+TEST_F(SchedUnitTests, testSched)
+{
+    HandleWrap hw;
+    lcb_t instance;
+    lcb_error_t rc;
+    size_t counter;
+    createConnection(hw, instance);
+
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, opCallback);
+
+    // lcb_store3
+    lcb_CMDSTORE scmd = { 0 };
+    LCB_CMD_SET_KEY(&scmd, "key", 3);
+    LCB_CMD_SET_VALUE(&scmd, "val", 3);
+    scmd.operation = LCB_SET;
+
+    rc = lcb_store3(instance, &counter, &scmd);
+    ASSERT_EQ(LCB_SUCCESS, rc);
+    ASSERT_TRUE(hasPendingOps(instance));
+    lcb_wait3(instance, LCB_WAIT_NOCHECK);
+    ASSERT_FALSE(hasPendingOps(instance));
+
+    lcb_sched_enter(instance);
+    rc = lcb_store3(instance, &counter, &scmd);
+    ASSERT_EQ(LCB_SUCCESS, rc);
+    ASSERT_FALSE(hasPendingOps(instance));
+    lcb_sched_leave(instance);
+    ASSERT_TRUE(hasPendingOps(instance));
+    lcb_wait3(instance, LCB_WAIT_NOCHECK);
+    ASSERT_FALSE(hasPendingOps(instance));
+
+    // Try with multiple operations..
+    counter = 0;
+    for (size_t ii = 0; ii < 5; ++ii) {
+        rc = lcb_store3(instance, &counter, &scmd);
+    }
+
+    ASSERT_TRUE(hasPendingOps(instance));
+    lcb_sched_enter(instance);
+    rc = lcb_store3(instance, &counter, &scmd);
+    lcb_sched_fail(instance);
+    lcb_wait3(instance, LCB_WAIT_NOCHECK);
+    ASSERT_EQ(5, counter);
+}

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

@@ -0,0 +1,230 @@
+/* -*- 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 <map>
+
+class ServeropsUnitTest : public MockUnitTest
+{
+};
+
+extern "C" {
+    static void testServerStatsCallback(lcb_t, const void *cookie,
+                                        lcb_error_t error,
+                                        const lcb_server_stat_resp_t *resp)
+    {
+        int *counter = (int *)cookie;
+        EXPECT_EQ(LCB_SUCCESS, error);
+        EXPECT_EQ(0, resp->version);
+        ++(*counter);
+    }
+    static void statKey_callback(lcb_t, int, const lcb_RESPBASE *resp_base) {
+        const lcb_RESPSTATS *resp = (const lcb_RESPSTATS *)resp_base;
+        if (!resp->server) {
+            return;
+        }
+        EXPECT_EQ(LCB_SUCCESS, resp->rc);
+        std::map<std::string,bool> &mm = *(std::map<std::string,bool>*)resp->cookie;
+        mm[resp->server] = true;
+    }
+}
+
+/**
+ * @test Server Statistics
+ * @pre Schedule a server statistics command
+ * @post The response is a valid statistics structure and its status is
+ * @c SUCCESS.
+ *
+ * @post the statistics callback is invoked more than once.
+ */
+TEST_F(ServeropsUnitTest, testServerStats)
+{
+    lcb_t instance;
+    HandleWrap hw;
+    createConnection(hw, instance);
+
+    (void)lcb_set_stat_callback(instance, testServerStatsCallback);
+    int numcallbacks = 0;
+    lcb_server_stats_cmd_t cmd;
+    lcb_server_stats_cmd_t *cmds[] = { &cmd };
+    EXPECT_EQ(LCB_SUCCESS, lcb_server_stats(instance, &numcallbacks, 1, cmds));
+    lcb_wait(instance);
+    EXPECT_LT(1, numcallbacks);
+}
+
+TEST_F(ServeropsUnitTest, testKeyStats)
+{
+    lcb_t instance;
+    HandleWrap hw;
+    createConnection(hw, instance);
+    lcb_install_callback3(instance, LCB_CALLBACK_STATS, statKey_callback);
+    lcb_CMDSTATS cmd = { 0 };
+
+    std::string key = "keystats_test";
+    storeKey(instance, key, "blah blah");
+    LCB_CMD_SET_KEY(&cmd, key.c_str(), key.size());
+    cmd.cmdflags = LCB_CMDSTATS_F_KV;
+    std::map<std::string,bool> mm;
+
+    lcb_sched_enter(instance);
+    lcb_error_t err = lcb_stats3(instance, &mm, &cmd);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    lcb_sched_leave(instance);
+
+    lcb_wait(instance);
+    ASSERT_EQ(lcb_get_num_replicas(instance)+1, mm.size());
+
+    // Ensure that a key with an embedded space fails
+    key = "key with space";
+    LCB_CMD_SET_KEY(&cmd, key.c_str(), key.size());
+    err = lcb_stats3(instance, NULL, &cmd);
+    ASSERT_NE(LCB_SUCCESS, err);
+}
+
+extern "C" {
+    static void testServerVersionsCallback(lcb_t, const void *cookie,
+                                           lcb_error_t error,
+                                           const lcb_server_version_resp_t *resp)
+    {
+        int *counter = (int *)cookie;
+        EXPECT_EQ(LCB_SUCCESS, error);
+        EXPECT_EQ(0, resp->version);
+        ++(*counter);
+    }
+}
+
+/**
+ * @test Server Versions
+ * @pre Request the server versions
+ * @post Response is successful, and the version callback is invoked more than
+ * once.
+ */
+TEST_F(ServeropsUnitTest, testServerVersion)
+{
+    lcb_t instance;
+    HandleWrap hw;
+    createConnection(hw, instance);
+
+    (void)lcb_set_version_callback(instance, testServerVersionsCallback);
+    int numcallbacks = 0;
+    lcb_server_version_cmd_t cmd;
+    lcb_server_version_cmd_t *cmds[] = { &cmd };
+    EXPECT_EQ(LCB_SUCCESS, lcb_server_versions(instance, &numcallbacks, 1, cmds));
+    lcb_wait(instance);
+    EXPECT_LT(1, numcallbacks);
+}
+
+
+extern "C" {
+    static void testFlushCallback(lcb_t, const void *cookie,
+                                  lcb_error_t error,
+                                  const lcb_flush_resp_t *resp)
+    {
+        int *counter = (int *)cookie;
+        EXPECT_TRUE(error == LCB_SUCCESS || error == LCB_NOT_SUPPORTED);
+        EXPECT_EQ(0, resp->version);
+        ++(*counter);
+    }
+}
+
+/**
+ * @test Flush
+ * @pre Request a flush operation
+ * @post Response is either a success or a @c NOT_SUPPORTED return
+ */
+TEST_F(ServeropsUnitTest, testFlush)
+{
+    lcb_t instance;
+    HandleWrap hw;
+    createConnection(hw, instance);
+
+    (void)lcb_set_flush_callback(instance, testFlushCallback);
+    int numcallbacks = 0;
+    lcb_flush_cmd_t cmd;
+    lcb_flush_cmd_t *cmds[] = { &cmd };
+    EXPECT_EQ(LCB_SUCCESS, lcb_flush(instance, &numcallbacks, 1, cmds));
+    lcb_wait(instance);
+    EXPECT_LT(1, numcallbacks);
+}
+
+extern "C" {
+    static char *verbosity_endpoint;
+
+    static void verbosity_all_callback(lcb_t instance,
+                                       const void *cookie,
+                                       lcb_error_t error,
+                                       const lcb_verbosity_resp_t *resp)
+    {
+        int *counter = (int *)cookie;
+        ASSERT_EQ(0, resp->version);
+        ASSERT_EQ(LCB_SUCCESS, error);
+        if (resp->v.v0.server_endpoint == NULL) {
+            EXPECT_EQ(MockEnvironment::getInstance()->getNumNodes(), *counter);
+            return;
+        } else if (verbosity_endpoint == NULL) {
+            verbosity_endpoint = strdup(resp->v.v0.server_endpoint);
+        }
+        ++(*counter);
+    }
+
+    static void verbosity_single_callback(lcb_t instance,
+                                          const void *,
+                                          lcb_error_t error,
+                                          const lcb_verbosity_resp_t *resp)
+    {
+        ASSERT_EQ(0, resp->version);
+        ASSERT_EQ(LCB_SUCCESS, error);
+        if (resp->v.v0.server_endpoint == NULL) {
+            return;
+        } else {
+            EXPECT_STREQ(verbosity_endpoint, resp->v.v0.server_endpoint);
+        }
+    }
+}
+
+/**
+ * @test Server Verbosity
+ * @todo (document this..)
+ */
+TEST_F(ServeropsUnitTest, testVerbosity)
+{
+    lcb_t instance;
+    HandleWrap hw;
+    createConnection(hw, instance);
+
+    (void)lcb_set_verbosity_callback(instance, verbosity_all_callback);
+
+    int counter = 0;
+
+    lcb_verbosity_cmd_t cmd(LCB_VERBOSITY_DEBUG);
+    lcb_verbosity_cmd_t *commands[] = { &cmd };
+    EXPECT_EQ(LCB_SUCCESS, lcb_set_verbosity(instance, &counter, 1, commands));
+    lcb_wait(instance);
+
+    EXPECT_EQ(MockEnvironment::getInstance()->getNumNodes(), counter);
+    EXPECT_NE((char *)NULL, verbosity_endpoint);
+
+    (void)lcb_set_verbosity_callback(instance, verbosity_single_callback);
+
+    lcb_verbosity_cmd_t cmd2(LCB_VERBOSITY_DEBUG, verbosity_endpoint);
+    lcb_verbosity_cmd_t *commands2[] = { &cmd2 };
+    EXPECT_EQ(LCB_SUCCESS, lcb_set_verbosity(instance, &counter, 1, commands2));
+    lcb_wait(instance);
+    free((void *)verbosity_endpoint);
+    verbosity_endpoint = NULL;
+
+}

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

@@ -0,0 +1,528 @@
+#include <gtest/gtest.h>
+#include "iotests.h"
+using std::vector;
+using std::string;
+
+// This file contains the 'migrated' tests from smoke-test.c
+
+static lcb_config_transport_t transports[] = {
+        LCB_CONFIG_TRANSPORT_HTTP, LCB_CONFIG_TRANSPORT_LIST_END };
+struct rvbuf {
+    lcb_error_t error;
+    lcb_storage_t operation;
+    vector<char> bytes;
+    vector<char> key;
+    lcb_cas_t cas;
+    lcb_uint32_t flags;
+    lcb_int32_t counter;
+    lcb_uint32_t errorCount;
+
+    template <typename T> void setKey(const T* resp) {
+        const char *ktmp, *kend;
+        ktmp = (const char*)resp->v.v0.key;
+        kend = ktmp + resp->v.v0.nkey;
+        key.assign(ktmp, kend);
+    }
+
+    void setValue(const lcb_get_resp_t *resp) {
+        const char *btmp = (const char*)resp->v.v0.bytes;
+        const char *bend = btmp + resp->v.v0.nbytes;
+        bytes.assign(btmp, bend);
+    }
+
+    string getKeyString() {
+        return string(key.begin(), key.end());
+    }
+
+    string getValueString() {
+        return string(bytes.begin(), bytes.end());
+    }
+
+    rvbuf() {
+        reset();
+    }
+
+    void reset() {
+        error = LCB_SUCCESS;
+        operation = LCB_SET;
+        cas = 0;
+        flags = 0;
+        counter = 0;
+        errorCount = 0;
+        key.clear();
+        bytes.clear();
+    }
+
+    void setError(lcb_error_t err) {
+        EXPECT_GT(counter, 0);
+        counter--;
+        if (err != LCB_SUCCESS) {
+            error = err;
+            errorCount++;
+        }
+    }
+    void incRemaining() { counter++; }
+};
+
+extern "C"
+{
+static void store_callback(lcb_t, const void *cookie, lcb_storage_t op,
+    lcb_error_t err, const lcb_store_resp_t *resp)
+{
+    rvbuf *rv = (rvbuf *)cookie;
+    rv->setError(err);
+    rv->setKey(resp);
+    rv->operation = op;
+}
+static void get_callback(lcb_t, const void *cookie, lcb_error_t err,
+    const lcb_get_resp_t *resp)
+{
+    rvbuf *rv = (rvbuf*)cookie;
+    rv->setError(err);
+    rv->setKey(resp);
+    if (err == LCB_SUCCESS) {
+        rv->setValue(resp);
+    }
+}
+static void touch_callback(lcb_t, const void *cookie, lcb_error_t err,
+    const lcb_touch_resp_t *resp)
+{
+    rvbuf *rv = (rvbuf *)cookie;
+    rv->setError(err);
+    rv->setKey(resp);
+    EXPECT_EQ(LCB_SUCCESS, err);
+}
+static void version_callback(lcb_t, const void *cookie, lcb_error_t err,
+    const lcb_server_version_resp_t *resp)
+{
+    const char *server_endpoint = (const char *)resp->v.v0.server_endpoint;
+    const char *vstring = (const char *)resp->v.v0.vstring;
+    lcb_size_t nvstring = resp->v.v0.nvstring;
+    rvbuf *rv = (rvbuf *)cookie;
+    char *str;
+    EXPECT_EQ(LCB_SUCCESS, err);
+
+    if (server_endpoint == NULL) {
+        assert(rv->counter == 0);
+        return;
+    }
+
+    rv->setError(err);
+    /*copy the key to an allocated buffer and ensure the key read from vstring
+     * will not segfault
+     */
+    str = (char *)malloc(nvstring);
+    memcpy(str, vstring, nvstring);
+    free(str);
+
+}
+} //extern "C"
+static void
+setupCallbacks(lcb_t instance)
+{
+    lcb_set_store_callback(instance, store_callback);
+    lcb_set_get_callback(instance, get_callback);
+    lcb_set_touch_callback(instance, touch_callback);
+    lcb_set_version_callback(instance, version_callback);
+}
+
+class SmokeTest : public ::testing::Test
+{
+protected:
+    MockEnvironment *mock;
+    lcb_t session;
+    void SetUp() {
+        assert(session == NULL);
+        session = NULL;
+        mock = NULL;
+    }
+
+    void TearDown() {
+        if (session != NULL) {
+            lcb_destroy(session);
+        }
+        if (mock != NULL) {
+            delete mock;
+        }
+
+        session = NULL;
+        mock = NULL;
+    }
+    void destroySession() {
+        if (session != NULL) {
+            lcb_destroy(session);
+            session = NULL;
+        }
+    }
+
+    SmokeTest() : mock(NULL), session(NULL) {}
+public:
+    void testSet1();
+    void testSet2();
+    void testGet1();
+    void testGet2();
+    void testTouch1();
+    void testVersion1();
+    void testSpuriousSaslError();
+    lcb_error_t testMissingBucket();
+
+    // Call to connect instance
+    void connectCommon(const char *password = NULL, lcb_error_t expected = LCB_SUCCESS);
+};
+
+void
+SmokeTest::testSet1()
+{
+    lcb_error_t err;
+    rvbuf rv;
+    lcb_store_cmd_t cmd;
+    const lcb_store_cmd_t *cmds[] = { &cmd };
+    memset(&cmd, 0, sizeof(cmd));
+
+    string key("foo");
+    string value("bar");
+
+    cmd.v.v0.key = key.c_str();
+    cmd.v.v0.nkey = key.size();
+    cmd.v.v0.bytes = value.c_str();
+    cmd.v.v0.nbytes = value.size();
+    cmd.v.v0.operation = LCB_SET;
+    err = lcb_store(session, &rv, 1, cmds);
+    rv.incRemaining();
+    EXPECT_EQ(LCB_SUCCESS, err);
+    lcb_wait(session);
+    EXPECT_EQ(LCB_SUCCESS, rv.error);
+    EXPECT_EQ(LCB_SET, rv.operation);
+    EXPECT_EQ(key, rv.getKeyString());
+}
+
+void
+SmokeTest::testSet2()
+{
+    lcb_error_t err;
+    struct rvbuf rv;
+    lcb_size_t ii;
+    lcb_store_cmd_t cmd;
+    const lcb_store_cmd_t *cmds[] = { &cmd };
+    string key("foo"), value("bar");
+
+    memset(&cmd, 0, sizeof(cmd));
+    cmd.v.v0.key = key.c_str();
+    cmd.v.v0.nkey = key.size();
+    cmd.v.v0.bytes = value.c_str();
+    cmd.v.v0.nbytes = value.size();
+    cmd.v.v0.operation = LCB_SET;
+
+    rv.errorCount = 0;
+    rv.counter = 0;
+    for (ii = 0; ii < 10; ++ii, rv.incRemaining()) {
+        err = lcb_store(session, &rv, 1, cmds);
+        EXPECT_EQ(LCB_SUCCESS, err);
+    }
+    lcb_wait(session);
+    EXPECT_EQ(0, rv.errorCount);
+}
+
+void
+SmokeTest::testGet1()
+{
+    lcb_error_t err;
+    struct rvbuf rv;
+    lcb_store_cmd_t storecmd;
+    const lcb_store_cmd_t *storecmds[] = { &storecmd };
+    lcb_get_cmd_t getcmd;
+    const lcb_get_cmd_t *getcmds[] = { &getcmd };
+    string key("foo"), value("bar");
+
+    memset(&storecmd, 0, sizeof(storecmd));
+    storecmd.v.v0.key = key.c_str();
+    storecmd.v.v0.nkey = key.size();
+    storecmd.v.v0.bytes = value.c_str();
+    storecmd.v.v0.nbytes = value.size();
+    storecmd.v.v0.operation = LCB_SET;
+    rv.incRemaining();
+    err = lcb_store(session, &rv, 1, storecmds);
+    EXPECT_EQ(LCB_SUCCESS, err);
+    lcb_wait(session);
+    EXPECT_EQ(LCB_SUCCESS, rv.error);
+
+    rv.reset();
+    memset(&getcmd, 0, sizeof(getcmd));
+    getcmd.v.v0.key = key.c_str();
+    getcmd.v.v0.nkey = key.size();
+    rv.incRemaining();
+    err = lcb_get(session, &rv, 1, getcmds);
+    EXPECT_EQ(LCB_SUCCESS, err);
+    lcb_wait(session);
+    EXPECT_EQ(rv.error, LCB_SUCCESS);
+    EXPECT_EQ(key, rv.getKeyString());
+    EXPECT_EQ(value, rv.getValueString());
+}
+
+static void
+genAZString(vector<string>& coll)
+{
+    string base("foo");
+    for (size_t ii = 0; ii < 26; ++ii) {
+        coll.push_back(base);
+        coll.back() += ('a' + ii);
+    }
+}
+
+void
+SmokeTest::testGet2()
+{
+    lcb_error_t err;
+    struct rvbuf rv;
+    string value("bar");
+    lcb_store_cmd_t storecmd;
+    const lcb_store_cmd_t *storecmds[] = { &storecmd };
+    lcb_get_cmd_t *getcmds[26];
+    vector<string> coll;
+    genAZString(coll);
+
+    for (size_t ii = 0; ii < coll.size(); ii++) {
+        const string& curKey = coll[ii];
+
+        memset(&storecmd, 0, sizeof(storecmd));
+        storecmd.v.v0.key = curKey.c_str();
+        storecmd.v.v0.nkey = curKey.size();
+        storecmd.v.v0.bytes = value.c_str();
+        storecmd.v.v0.nbytes = value.size();
+        storecmd.v.v0.operation = LCB_SET;
+        err = lcb_store(session, &rv, 1, storecmds);
+        EXPECT_EQ(LCB_SUCCESS, err);
+        rv.incRemaining();
+        lcb_wait(session);
+        EXPECT_EQ(LCB_SUCCESS, rv.error);
+
+        rv.reset();
+        getcmds[ii] = (lcb_get_cmd_t *)calloc(1, sizeof(lcb_get_cmd_t));
+        EXPECT_FALSE(NULL == getcmds[ii]);
+        getcmds[ii]->v.v0.key = curKey.c_str();
+        getcmds[ii]->v.v0.nkey = curKey.size();
+    }
+
+    rv.counter = coll.size();
+    err = lcb_get(session, &rv, coll.size(), (const lcb_get_cmd_t * const *)getcmds);
+    EXPECT_EQ(LCB_SUCCESS, err);
+    lcb_wait(session);
+    EXPECT_EQ(LCB_SUCCESS, rv.error);
+    EXPECT_EQ(value, rv.getValueString());
+
+    for (size_t ii = 0; ii < 26; ii++) {
+        free(getcmds[ii]);
+    }
+}
+
+void
+SmokeTest::testTouch1()
+{
+    lcb_error_t err;
+    struct rvbuf rv;
+    lcb_store_cmd_t storecmd;
+    const lcb_store_cmd_t *storecmds[] = { &storecmd };
+    lcb_touch_cmd_t *touchcmds[26];
+    vector<string> coll;
+    string value("bar");
+    genAZString(coll);
+    for (size_t ii = 0; ii < coll.size(); ii++) {
+        const string& curKey = coll[ii];
+        memset(&storecmd, 0, sizeof(storecmd));
+        storecmd.v.v0.key = curKey.c_str();
+        storecmd.v.v0.nkey = curKey.size();
+        storecmd.v.v0.bytes = value.c_str();
+        storecmd.v.v0.nbytes = value.size();
+        storecmd.v.v0.operation = LCB_SET;
+        err = lcb_store(session, &rv, 1, storecmds);
+        EXPECT_EQ(LCB_SUCCESS, err);
+        rv.incRemaining();
+        lcb_wait(session);
+        EXPECT_EQ(LCB_SUCCESS, rv.error);
+
+        rv.reset();
+        touchcmds[ii] = (lcb_touch_cmd_t*)calloc(1, sizeof(lcb_touch_cmd_t));
+        EXPECT_FALSE(touchcmds[ii] == NULL);
+        touchcmds[ii]->v.v0.key = curKey.c_str();
+        touchcmds[ii]->v.v0.nkey = curKey.size();
+    }
+
+    rv.counter = coll.size();
+    err = lcb_touch(session, &rv, coll.size(), (const lcb_touch_cmd_t * const *)touchcmds);
+    EXPECT_EQ(LCB_SUCCESS, err);
+    lcb_wait(session);
+    EXPECT_EQ(LCB_SUCCESS, rv.error);
+    for (size_t ii = 0; ii < coll.size(); ii++) {
+        free(touchcmds[ii]);
+    }
+}
+
+void
+SmokeTest::testVersion1()
+{
+    lcb_error_t err;
+    struct rvbuf rv;
+    lcb_server_version_cmd_t cmd;
+    const lcb_server_version_cmd_t *cmds[] = { &cmd };
+    memset(&cmd, 0, sizeof(cmd));
+
+    err = lcb_server_versions(session, &rv, 1, cmds);
+    EXPECT_EQ(LCB_SUCCESS, err);
+    rv.counter = mock->getNumNodes();
+    lcb_wait(session);
+    EXPECT_EQ(LCB_SUCCESS, rv.error);
+    EXPECT_EQ(0, rv.counter);
+}
+
+lcb_error_t
+SmokeTest::testMissingBucket()
+{
+    destroySession();
+    // create a new session
+    lcb_create_st cropts;
+    mock->makeConnectParams(cropts);
+    cropts.v.v2.transports = transports;
+    cropts.v.v2.bucket = "nonexist";
+    cropts.v.v2.user = "nonexist";
+    lcb_error_t err;
+    err = lcb_create(&session, &cropts);
+    EXPECT_EQ(LCB_SUCCESS, err);
+    mock->postCreate(session);
+
+    err = lcb_connect(session);
+    EXPECT_EQ(LCB_SUCCESS, err);
+    lcb_wait(session);
+    err = lcb_get_bootstrap_status(session);
+    EXPECT_NE(LCB_SUCCESS, err);
+    EXPECT_TRUE(err == LCB_BUCKET_ENOENT||err == LCB_AUTH_ERROR);
+    destroySession();
+    return err;
+}
+
+void
+SmokeTest::testSpuriousSaslError()
+{
+    int iterations = 50;
+    rvbuf rvs[50];
+    int i;
+    lcb_error_t err;
+    lcb_store_cmd_t storecmd;
+    const lcb_store_cmd_t *storecmds[] = { &storecmd };
+
+    for (i = 0; i < iterations; i++) {
+        rvs[i].counter = 999;
+        memset(&storecmd, 0, sizeof(storecmd));
+        storecmd.v.v0.key = "KEY";
+        storecmd.v.v0.nkey = strlen((const char *)storecmd.v.v0.key);
+        storecmd.v.v0.bytes = "KEY";
+        storecmd.v.v0.nbytes = strlen((const char *)storecmd.v.v0.bytes);
+        storecmd.v.v0.operation = LCB_SET;
+        err = lcb_store(session, rvs + i, 1, storecmds);
+        EXPECT_EQ(LCB_SUCCESS, err);
+    }
+    lcb_wait(session);
+
+    for (i = 0; i < iterations; i++) {
+        const char *errinfo = NULL;
+        if (rvs[i].errorCount != LCB_SUCCESS) {
+            errinfo = "Did not get success response";
+        } else if (rvs[i].key.size() != 3) {
+            errinfo = "Did not get expected key length";
+        } else if (rvs[i].getKeyString() != string("KEY")) {
+            errinfo = "Weird key size";
+        }
+        if (errinfo) {
+            EXPECT_FALSE(true) << errinfo;
+        }
+    }
+}
+
+void
+SmokeTest::connectCommon(const char *password, lcb_error_t expected)
+{
+    lcb_create_st cropts;
+    mock->makeConnectParams(cropts, NULL);
+
+    if (password != NULL) {
+        cropts.v.v2.passwd = password;
+    }
+    cropts.v.v2.transports = transports;
+    lcb_error_t err = lcb_create(&session, &cropts);
+    EXPECT_EQ(LCB_SUCCESS, err);
+
+    mock->postCreate(session);
+    err = lcb_connect(session);
+    EXPECT_EQ(LCB_SUCCESS, err);
+    lcb_wait(session);
+    EXPECT_EQ(expected, lcb_get_bootstrap_status(session));
+    setupCallbacks(session);
+}
+
+TEST_F(SmokeTest, testMemcachedBucket)
+{
+    SKIP_UNLESS_MOCK();
+    const char *args[] = { "--buckets", "default::memcache", NULL };
+    mock = new MockEnvironment(args);
+    mock->setCCCP(false);
+    connectCommon();
+    testSet1();
+    testSet2();
+    testGet1();
+    testGet2();
+    testVersion1();
+
+    // A bit out of place, but check that replica commands fail at schedule-time
+    lcb_sched_enter(session);
+    lcb_CMDGETREPLICA cmd = { 0 };
+    LCB_CMD_SET_KEY(&cmd, "key", 3);
+    lcb_error_t rc;
+
+    cmd.strategy = LCB_REPLICA_FIRST;
+    rc = lcb_rget3(session, NULL, &cmd);
+    ASSERT_EQ(LCB_NO_MATCHING_SERVER, rc);
+
+    cmd.strategy = LCB_REPLICA_ALL;
+    rc = lcb_rget3(session, NULL, &cmd);
+    ASSERT_EQ(LCB_NO_MATCHING_SERVER, rc);
+
+    cmd.strategy = LCB_REPLICA_SELECT;
+    cmd.index = 0;
+    rc = lcb_rget3(session, NULL, &cmd);
+    ASSERT_EQ(LCB_NO_MATCHING_SERVER, rc);
+
+
+    testMissingBucket();
+}
+
+TEST_F(SmokeTest, testCouchbaseBucket)
+{
+    SKIP_UNLESS_MOCK();
+    const char *args[] = { "--buckets", "default::couchbase", NULL };
+    mock = new MockEnvironment(args);
+    mock->setCCCP(false);
+    connectCommon();
+    testSet1();
+    testSet2();
+    testGet1();
+    testGet2();
+    testVersion1();
+    testMissingBucket();
+}
+
+TEST_F(SmokeTest, testSaslBucket)
+{
+    SKIP_UNLESS_MOCK();
+    const char *args[] = { "--buckets", "protected:secret:couchbase", NULL };
+    mock = new MockEnvironment(args, "protected");
+    mock->setCCCP(false);
+
+
+    testMissingBucket();
+
+    connectCommon("secret");
+    testSpuriousSaslError();
+
+    destroySession();
+    connectCommon("incorrect", LCB_AUTH_ERROR);
+    destroySession();
+}