libcouchbase 0.0.1

data/ext/libcouchbase/tests/iotests/mock-unit-test.h

@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010-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.
+ */
+#ifndef TESTS_MOCK_UNIT_TESTS_H
+#define TESTS_MOCK_UNIT_TESTS_H 1
+
+#include "config.h"
+#include <gtest/gtest.h>
+#include <libcouchbase/couchbase.h>
+#include "mock-environment.h"
+
+class HandleWrap;
+
+#define SKIP_IF_MOCK()                                                  \
+    if (!getenv(LCB_TEST_REALCLUSTER_ENV)) {                            \
+         std::cerr << "Skipping: Need real cluster\n" << std::endl; \
+        return;                                                         \
+    }
+
+#define SKIP_UNLESS_MOCK() \
+    if (getenv(LCB_TEST_REALCLUSTER_ENV)) { \
+        std::cerr << "Skipping: Need mock cluster\n" << std::endl; \
+        return; \
+    }
+
+#define ASSERT_ERRISA(err, et) \
+        ASSERT_EQ(et, (int)lcb_get_errtype(err) & (int)et)
+
+class MockUnitTest : public ::testing::Test
+{
+protected:
+    virtual void SetUp();
+    virtual void createConnection(lcb_t &instance);
+    virtual void createConnection(HandleWrap &handle);
+    virtual void createConnection(HandleWrap &handle, lcb_t &instance);
+    virtual lcb_error_t tryCreateConnection(HandleWrap &hw,
+        lcb_t &instance, lcb_create_st &crparams);
+
+    // A mock "Transaction"
+    void doMockTxn(MockCommand &cmd) {
+        MockEnvironment::getInstance()->sendCommand(cmd);
+        MockResponse tmp;
+        MockEnvironment::getInstance()->getResponse(tmp);
+        ASSERT_TRUE(tmp.isOk());
+    }
+};
+
+#endif

data/ext/libcouchbase/tests/iotests/serverparams.h

@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010-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.
+ */
+#ifndef TESTS_SERVER_PARAMS_H
+#define TESTS_SERVER_PARAMS_H 1
+
+#include "config.h"
+#include <string>
+#include <string.h>
+#include <libcouchbase/couchbase.h>
+
+class ServerParams
+{
+public:
+    ServerParams() { }
+    ServerParams(const char *h, const char *b, const char *u, const char *p) {
+        loadParam(host, h);
+        loadParam(bucket, b);
+        loadParam(user, u);
+        loadParam(pass, p);
+    }
+
+    void makeConnectParams(lcb_create_st &crst, lcb_io_opt_t io) {
+        memset(&crst, 0, sizeof(crst));
+        crst.version = 2;
+        crst.v.v2.host = host.c_str();
+        crst.v.v2.bucket = bucket.c_str();
+        crst.v.v2.user = user.c_str();
+        crst.v.v2.passwd = pass.c_str();
+        crst.v.v2.io = io;
+        if (!mcNodes.empty()) {
+            crst.v.v2.mchosts = mcNodes.c_str();
+        }
+    }
+
+    void setMcPorts(const std::vector<int>& portlist) {
+        std::stringstream ss;
+        std::vector<int>::const_iterator ii = portlist.begin();
+        for (; ii != portlist.end(); ii++) {
+            ss << "localhost";
+            ss << ":";
+            ss << std::dec << *ii;
+            ss << ";";
+        }
+        mcNodes = ss.str();
+    }
+
+protected:
+    std::string host;
+    std::string user;
+    std::string pass;
+    std::string bucket;
+    std::string mcNodes;
+
+private:
+    void loadParam(std::string &d, const char *s) {
+        if (s) {
+            d.assign(s);
+        }
+    }
+};
+
+#endif

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,226 @@
+/* -*- 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(info.v.v0.os_default, EXPECTED_DEFAULT);
+    ASSERT_EQ(info.v.v0.effective, 0);
+
+    lcb_t instance2;
+    ASSERT_EQ(lcb_create(&instance2, NULL), LCB_DLOPEN_FAILED);
+
+    setPluginEnv("foobarbaz", "");
+    ASSERT_EQ(lcb_create(&instance2, NULL), LCB_BAD_ENVIRONMENT);
+
+    // 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
+
+    setPluginEnv(dllname, "nonexist-symbol");
+    ASSERT_EQ(lcb_create(&instance2, NULL), LCB_DLSYM_FAILED);
+
+}