libcouchbase 1.2.8 → 1.3.0

data/ext/libcouchbase/tests/check-all.cc

@@ -404,7 +404,7 @@ static void setLinkerEnvironment(std::string &path)
         newenv += ":";
     }
     newenv += path;
-    fprintf(stderr, "%s=%s\n", varname, newenv.c_str());
+    fprintf(stderr, "export %s=%s\n", varname, newenv.c_str());
     setenv(varname, newenv.c_str(), 1);
 }
 
@@ -562,6 +562,7 @@ static bool runSingleCycle(TestConfiguration &config)
                 iterbins++) {
 
             std::string cmdline = config.setupCommandline(*iterbins);
+            fprintf(stderr, "Command line '%s'\n", cmdline.c_str());
             scheduler.schedule(Process(*iter, *iterbins, cmdline, config));
         }
 
@@ -584,19 +585,22 @@ int main(int argc, char **argv)
 
     // Set the environment for 'srcdir'
     std::stringstream ss;
-    fprintf(stderr, "%s=%s\n", LCB_SRCROOT_ENV_VAR, config.srcroot.c_str());
+    fprintf(stderr, "export %s=%s\n", LCB_SRCROOT_ENV_VAR, config.srcroot.c_str());
     setenv(LCB_SRCROOT_ENV_VAR, config.srcroot.c_str(), 1);
+    fprintf(stderr, "export LCB_VERBOSE_TESTS=1\n");
     setenv("LCB_VERBOSE_TESTS", "1", 1);
 
     char loglevel_s[4096] = { 0 };
     if (config.getVerbosityLevel() > 0) {
         sprintf(loglevel_s, "%d", config.getVerbosityLevel());
         setenv("LCB_LOGLEVEL", loglevel_s, 0);
+        fprintf(stderr, "export LCB_LOGLEVEL=%s\n", loglevel_s);
     }
 
     if (!config.realClusterEnv.empty()) {
         // format the string
         setenv("LCB_TEST_CLUSTER_CONF", config.realClusterEnv.c_str(), 0);
+        fprintf(stderr, "export LCB_TEST_CLUSTER_CONF=%s\n", config.realClusterEnv.c_str());
     }
 
     for (int ii = 0; ii < config.maxCycles; ii++) {

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

@@ -122,6 +122,35 @@ std::vector<int> MockEnvironment::getMcPorts(std::string bucket)
     return ret;
 }
 
+void MockEnvironment::setSaslMechs(std::vector<std::string>& mechanisms, std::string bucket,
+                                   const std::vector<int>* nodes)
+{
+    MockCommand cmd(MockCommand::SET_SASL_MECHANISMS);
+    Json::Value mechs(Json::arrayValue);
+    for (std::vector<std::string>::const_iterator ii = mechanisms.begin(); ii != mechanisms.end(); ii++) {
+        mechs.append(*ii);
+    }
+    cmd.set("mechs", mechs);
+
+    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::setCCCP(bool enabled, std::string bucket,
                               const std::vector<int>* nodes)
 {
@@ -172,6 +201,41 @@ void MockEnvironment::setEnhancedErrors(bool enabled, std::string bucket,
     getResponse();
 }
 
+void MockEnvironment::setCompression(std::string mode, std::string bucket,
+                                     const std::vector<int>* nodes)
+{
+    MockCommand cmd(MockCommand::SET_COMPRESSION);
+    cmd.set("mode", mode);
+
+    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();
+}
+
+const Json::Value MockEnvironment::getKeyInfo(std::string key, std::string bucket)
+{
+    MockKeyCommand cmd(MockCommand::KEYINFO, key);
+    cmd.bucket = bucket;
+    sendCommand(cmd);
+    MockResponse resp;
+    getResponse(resp);
+    return resp.constResp()["payload"];
+}
+
 void MockEnvironment::sendCommand(MockCommand &cmd)
 {
     std::string s = cmd.encode();

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

@@ -75,7 +75,9 @@ class MockCommand
     X(OPFAIL) \
     X(START_RETRY_VERIFY) \
     X(CHECK_RETRY_VERIFY) \
-    X(SET_ENHANCED_ERRORS)
+    X(SET_ENHANCED_ERRORS) \
+    X(SET_COMPRESSION) \
+    X(SET_SASL_MECHANISMS)
 
 public:
     enum Code {
@@ -305,6 +307,16 @@ public:
      */
     std::vector<int> getMcPorts(std::string bucket = "default");
 
+    /**
+     * Enable SASL mechanisms on the mock cluster
+     * @param mechanisms list of mechanisms to enable
+     * @param bucket the bucket on which to enable these mechanisms
+     * @param nodes a list of by-index nodes on which to enable mechanisms. If NULL
+     * then all nodes are enabled
+     */
+    void setSaslMechs(std::vector<std::string>& mechanisms, std::string bucket = "",
+                      const std::vector<int>* nodes = NULL);
+
     /**
      * Enable CCCP on the mock cluster
      * @param bucket the bucket on which to enable CCCP
@@ -329,6 +341,20 @@ public:
                            std::string bucket = "",
                            const std::vector<int>* nodes = NULL);
 
+    /**
+     * Change compression mode on the server
+     *
+     * @param mode compression mode ("off", "passive", "active")
+     * @param bucket the bucket on which to enable compression
+     * @param nodes a list of by-index nodes on which to enable compression. If NULL
+     * then all nodes are enabled
+     */
+    void setCompression(std::string mode,
+                        std::string bucket = "",
+                        const std::vector<int>* nodes = NULL);
+
+    const Json::Value getKeyInfo(std::string key, std::string bucket = "");
+
     /**
      * Create a connection to the mock/real server.
      *

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

@@ -46,7 +46,7 @@ TEST_F(ConfmonTest, testBasic)
     MockEnvironment::getInstance()->createConnection(hw, instance);
 
 
-    Confmon *mon = new Confmon(instance->settings, instance->iotable);
+    Confmon *mon = new Confmon(instance->settings, instance->iotable, instance);
     Provider *http = mon->get_provider(CLCONFIG_HTTP);
     http->enable();
     http->configure_nodes(*instance->ht_nodes);
@@ -130,7 +130,7 @@ TEST_F(ConfmonTest, testCycle)
     instance->settings->bc_http_stream_time = 100000;
     instance->memd_sockpool->get_options().tmoidle = 100000;
 
-    Confmon *mon = new Confmon(instance->settings, instance->iotable);
+    Confmon *mon = new Confmon(instance->settings, instance->iotable, instance);
 
     struct listener2 lsn;
     lsn.io = instance->iotable;

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

@@ -8,6 +8,14 @@ using namespace PacketMaker;
 
 class ForwardTests : public MockUnitTest
 {
+protected:
+    virtual void createConnection(HandleWrap& hw, lcb_t& instance) {
+        MockEnvironment::getInstance()->createConnection(hw, instance);
+        lcb_cntl_string(instance, "enable_tracing", "off");
+        ASSERT_EQ(LCB_SUCCESS, lcb_connect(instance));
+        lcb_wait(instance);
+        ASSERT_EQ(LCB_SUCCESS, lcb_get_bootstrap_status(instance));
+    }
 };
 
 struct ForwardCookie {

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

@@ -537,6 +537,130 @@ TEST_F(MockUnitTest, testSaslMechs)
     lcb_destroy(instance);
 }
 
+TEST_F(MockUnitTest, testSaslSHA)
+{
+    // Ensure our SASL mech listing works.
+    SKIP_UNLESS_MOCK();
+
+    const char *argv[] = { "--buckets", "protected:secret:couchbase", NULL };
+
+    lcb_t instance = NULL;
+    lcb_error_t err;
+    struct lcb_create_st crParams;
+    MockEnvironment mock_o(argv, "protected"), *protectedEnv = &mock_o;
+    protectedEnv->makeConnectParams(crParams, NULL);
+    protectedEnv->setCCCP(false);
+
+    crParams.v.v2.user = "protected";
+    crParams.v.v2.passwd = "secret";
+    crParams.v.v2.bucket = "protected";
+    crParams.v.v2.mchosts = NULL;
+
+    {
+        doLcbCreate(&instance, &crParams, protectedEnv);
+
+        // Make the socket pool disallow idle connections
+        instance->memd_sockpool->get_options().maxidle = 0;
+
+        ASSERT_EQ(LCB_SUCCESS, lcb_connect(instance));
+        ASSERT_EQ(LCB_SUCCESS, lcb_wait(instance));
+
+        err = lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_FORCE_SASL_MECH, (void *)"SCRAM-SHA512");
+        ASSERT_EQ(LCB_SUCCESS, err);
+
+        Item itm("key", "value");
+        KVOperation kvo(&itm);
+
+        kvo.allowableErrors.insert(LCB_SASLMECH_UNAVAILABLE);
+        kvo.allowableErrors.insert(LCB_ETIMEDOUT);
+        kvo.store(instance);
+
+        ASSERT_FALSE(kvo.globalErrors.find(LCB_SASLMECH_UNAVAILABLE) == kvo.globalErrors.end());
+
+        lcb_destroy(instance);
+    }
+
+    std::vector<std::string> mechs;
+    mechs.push_back("SCRAM-SHA512");
+    protectedEnv->setSaslMechs(mechs);
+
+    {
+        instance = NULL;
+        doLcbCreate(&instance, &crParams, protectedEnv);
+
+        // Make the socket pool disallow idle connections
+        instance->memd_sockpool->get_options().maxidle = 0;
+
+        ASSERT_EQ(LCB_SUCCESS, lcb_connect(instance));
+        ASSERT_EQ(LCB_SUCCESS, lcb_wait(instance));
+
+        Item itm("key", "value");
+        KVOperation kvo(&itm);
+
+        kvo.allowableErrors.insert(LCB_SASLMECH_UNAVAILABLE);
+        kvo.allowableErrors.insert(LCB_ETIMEDOUT);
+        kvo.store(instance);
+
+#ifndef LCB_NO_SSL
+        err = lcb_cntl(instance, LCB_CNTL_SET, LCB_CNTL_FORCE_SASL_MECH, (void *)"SCRAM-SHA512");
+        ASSERT_EQ(LCB_SUCCESS, err);
+
+        kvo.clear();
+        kvo.store(instance);
+#endif
+
+        lcb_destroy(instance);
+    }
+}
+
+
+extern "C" {
+static const char *get_username(void *cookie, const char *host, const char *port, const char *bucket)
+{
+    return bucket;
+}
+
+static const char *get_password(void *cookie, const char *host, const char *port, const char *bucket)
+{
+    std::map< std::string, std::string > *credentials = static_cast< std::map< std::string, std::string > * >(cookie);
+    return (*credentials)[bucket].c_str();
+}
+}
+
+TEST_F(MockUnitTest, testDynamicAuth)
+{
+    SKIP_UNLESS_MOCK();
+
+    const char *argv[] = {"--buckets", "protected:secret:couchbase", NULL};
+
+    lcb_t instance;
+    lcb_error_t err;
+    struct lcb_create_st crParams;
+    MockEnvironment mock_o(argv, "protected"), *mock = &mock_o;
+    mock->makeConnectParams(crParams, NULL);
+    mock->setCCCP(false);
+
+    crParams.v.v0.bucket = "protected";
+    doLcbCreate(&instance, &crParams, mock);
+
+    std::map< std::string, std::string > credentials;
+    credentials["protected"] = "secret";
+    lcb_AUTHENTICATOR *auth = lcbauth_new();
+    lcbauth_set_callbacks(auth, &credentials, get_username, get_password);
+    lcbauth_set_mode(auth, LCBAUTH_MODE_DYNAMIC);
+    lcb_set_auth(instance, auth);
+
+    err = lcb_connect(instance);
+    ASSERT_EQ(LCB_SUCCESS, err);
+    ASSERT_EQ(LCB_SUCCESS, lcb_wait(instance));
+
+    Item itm("key", "value");
+    KVOperation kvo(&itm);
+    kvo.store(instance);
+    lcb_destroy(instance);
+    lcbauth_unref(auth);
+}
+
 static void
 doManyItems(lcb_t instance, std::vector<std::string> keys)
 {

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

@@ -497,7 +497,7 @@ TEST_F(SmokeTest, testMemcachedBucket)
 TEST_F(SmokeTest, testCouchbaseBucket)
 {
     SKIP_UNLESS_MOCK();
-    const char *args[] = { "--buckets", "default::couchbase", NULL };
+    const char *args[] = { "--buckets", "default::couchbase", "--debug", NULL };
     mock = new MockEnvironment(args);
     mock->setCCCP(false);
     connectCommon();

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

@@ -0,0 +1,316 @@
+#include "config.h"
+#include "iotests.h"
+#include "internal.h"
+
+class SnappyUnitTest : public MockUnitTest
+{
+  protected:
+    void setCompression(std::string mode)
+    {
+        MockEnvironment::getInstance()->setCompression(mode);
+    }
+
+    bool isCompressed(std::string &key)
+    {
+        const Json::Value info = MockEnvironment::getInstance()->getKeyInfo(key);
+        for (Json::Value::const_iterator ii = info.begin(); ii != info.end(); ii++) {
+            const Json::Value &node = *ii;
+            if (node.isNull()) {
+                continue;
+            }
+            if (node["Conf"]["Type"] == "master") {
+                return node["Cache"]["Snappy"].asBool();
+            }
+        }
+        return false;
+    }
+};
+
+struct SnappyCookie {
+    lcb_error_t rc;
+    bool called;
+    std::string value;
+
+    void reset()
+    {
+        rc = LCB_SUCCESS;
+        called = false;
+    }
+    SnappyCookie() : rc(LCB_SUCCESS), called(false) {}
+
+    ~SnappyCookie() {}
+};
+
+extern "C" {
+static void storecb(lcb_t, int, const lcb_RESPBASE *rb)
+{
+    SnappyCookie *cookie = reinterpret_cast< SnappyCookie * >(rb->cookie);
+    cookie->called = true;
+    cookie->rc = rb->rc;
+}
+static void getcb(lcb_t, int, const lcb_RESPBASE *rb)
+{
+    SnappyCookie *cookie = reinterpret_cast< SnappyCookie * >(rb->cookie);
+    cookie->called = true;
+    cookie->rc = rb->rc;
+    const lcb_RESPGET *resp = reinterpret_cast< const lcb_RESPGET * >(rb);
+    cookie->value.assign((char *)resp->value, resp->nvalue);
+}
+}
+
+TEST_F(SnappyUnitTest, testSpec)
+{
+    SKIP_UNLESS_MOCK();
+    HandleWrap hw;
+    lcb_t instance;
+
+    setCompression("passive");
+    createConnection(hw, instance);
+    lcb_cntl_setu32(instance, LCB_CNTL_COMPRESSION_OPTS, LCB_COMPRESS_INOUT);
+    lcb_install_callback3(instance, LCB_CALLBACK_GET, getcb);
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, storecb);
+
+    std::string key("hello");
+    std::string value("A big black bug bit a big black bear, made the big black bear bleed blood");
+    std::string compressed("IPA big black bug bit a.\x14");
+
+    SnappyCookie cookie;
+    lcb_CMDSTORE scmd;
+    lcb_CMDGET gcmd;
+
+    scmd = lcb_CMDSTORE();
+    scmd.operation = LCB_UPSERT;
+    LCB_CMD_SET_KEY(&scmd, key.c_str(), key.size());
+    LCB_CMD_SET_VALUE(&scmd, value.c_str(), value.size());
+    cookie = SnappyCookie();
+    lcb_store3(instance, &cookie, &scmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+    /* now we have negotiated snappy feature */
+    cookie = SnappyCookie();
+    lcb_store3(instance, &cookie, &scmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+
+    cookie = SnappyCookie();
+    gcmd = lcb_CMDGET();
+    LCB_CMD_SET_KEY(&gcmd, key.c_str(), key.size());
+    lcb_get3(instance, &cookie, &gcmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+    ASSERT_STREQ(value.c_str(), cookie.value.c_str());
+    ASSERT_TRUE(isCompressed(key));
+
+    lcb_cntl_setu32(instance, LCB_CNTL_COMPRESSION_OPTS, LCB_COMPRESS_OUT);
+    cookie = SnappyCookie();
+    gcmd = lcb_CMDGET();
+    LCB_CMD_SET_KEY(&gcmd, key.c_str(), key.size());
+    lcb_get3(instance, &cookie, &gcmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+    ASSERT_STREQ(compressed.c_str(), cookie.value.c_str());
+
+    setCompression("off");
+    createConnection(hw, instance);
+    lcb_cntl_setu32(instance, LCB_CNTL_COMPRESSION_OPTS, LCB_COMPRESS_INOUT);
+    lcb_install_callback3(instance, LCB_CALLBACK_GET, getcb);
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, storecb);
+
+    cookie = SnappyCookie();
+    gcmd = lcb_CMDGET();
+    LCB_CMD_SET_KEY(&gcmd, key.c_str(), key.size());
+    lcb_get3(instance, &cookie, &gcmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+    ASSERT_STREQ(value.c_str(), cookie.value.c_str());
+
+    cookie = SnappyCookie();
+    lcb_store3(instance, &cookie, &scmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+    ASSERT_FALSE(isCompressed(key));
+}
+
+TEST_F(SnappyUnitTest, testIOV)
+{
+
+    SKIP_UNLESS_MOCK();
+    HandleWrap hw;
+    lcb_t instance;
+
+    setCompression("passive");
+    createConnection(hw, instance);
+    lcb_cntl_setu32(instance, LCB_CNTL_COMPRESSION_OPTS, LCB_COMPRESS_INOUT);
+    lcb_install_callback3(instance, LCB_CALLBACK_GET, getcb);
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, storecb);
+
+    std::string key("hello");
+    std::string value1("A big black bug bit ");
+    std::string value2("a big black bear, ");
+    std::string value3("made the big black ");
+    std::string value4("bear bleed blood");
+    std::string value = value1 + value2 + value3 + value4;
+    std::string compressed("IPA big black bug bit a.\x14");
+
+    SnappyCookie cookie;
+    lcb_CMDSTORE scmd;
+    lcb_CMDGET gcmd;
+
+    lcb_IOV iov[4];
+    unsigned int niov = 4;
+    iov[0].iov_base = (void *)value1.c_str();
+    iov[0].iov_len = value1.size();
+    iov[1].iov_base = (void *)value2.c_str();
+    iov[1].iov_len = value2.size();
+    iov[2].iov_base = (void *)value3.c_str();
+    iov[2].iov_len = value3.size();
+    iov[3].iov_base = (void *)value4.c_str();
+    iov[3].iov_len = value4.size();
+
+    scmd = lcb_CMDSTORE();
+    scmd.operation = LCB_UPSERT;
+    LCB_CMD_SET_KEY(&scmd, key.c_str(), key.size());
+    LCB_CMD_SET_VALUEIOV(&scmd, iov, niov);
+    cookie = SnappyCookie();
+    lcb_store3(instance, &cookie, &scmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+    /* now we have negotiated snappy feature */
+    cookie = SnappyCookie();
+    lcb_store3(instance, &cookie, &scmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+
+    cookie = SnappyCookie();
+    gcmd = lcb_CMDGET();
+    LCB_CMD_SET_KEY(&gcmd, key.c_str(), key.size());
+    lcb_get3(instance, &cookie, &gcmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+    ASSERT_STREQ(value.c_str(), cookie.value.c_str());
+    ASSERT_TRUE(isCompressed(key));
+
+    lcb_cntl_setu32(instance, LCB_CNTL_COMPRESSION_OPTS, LCB_COMPRESS_OUT);
+    cookie = SnappyCookie();
+    gcmd = lcb_CMDGET();
+    LCB_CMD_SET_KEY(&gcmd, key.c_str(), key.size());
+    lcb_get3(instance, &cookie, &gcmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+    ASSERT_STREQ(compressed.c_str(), cookie.value.c_str());
+}
+
+
+TEST_F(SnappyUnitTest, testSettings)
+{
+
+    SKIP_UNLESS_MOCK();
+    HandleWrap hw;
+    lcb_t instance;
+
+    setCompression("passive");
+    createConnection(hw, instance);
+    lcb_cntl_string(instance, "compression", "deflate_only");
+    lcb_install_callback3(instance, LCB_CALLBACK_GET, getcb);
+    lcb_install_callback3(instance, LCB_CALLBACK_STORE, storecb);
+
+    std::string key("hello");
+    std::string value("A big black bug bit a big black bear, made the big black bear bleed blood");
+    std::string compressed("IPA big black bug bit a.\x14");
+
+    SnappyCookie cookie;
+    lcb_CMDSTORE scmd;
+    lcb_CMDGET gcmd;
+
+    scmd = lcb_CMDSTORE();
+    scmd.operation = LCB_UPSERT;
+    LCB_CMD_SET_KEY(&scmd, key.c_str(), key.size());
+    LCB_CMD_SET_VALUE(&scmd, value.c_str(), value.size());
+    cookie = SnappyCookie();
+    lcb_store3(instance, &cookie, &scmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+    /* now we have negotiated snappy feature */
+    cookie = SnappyCookie();
+    lcb_store3(instance, &cookie, &scmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+
+    value = "A big black bug";
+    compressed = "A big black bug";
+    scmd = lcb_CMDSTORE();
+    scmd.operation = LCB_UPSERT;
+    LCB_CMD_SET_KEY(&scmd, key.c_str(), key.size());
+    LCB_CMD_SET_VALUE(&scmd, value.c_str(), value.size());
+    cookie = SnappyCookie();
+    lcb_store3(instance, &cookie, &scmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+
+    cookie = SnappyCookie();
+    gcmd = lcb_CMDGET();
+    LCB_CMD_SET_KEY(&gcmd, key.c_str(), key.size());
+    lcb_get3(instance, &cookie, &gcmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+    ASSERT_STREQ(compressed.c_str(), cookie.value.c_str());
+
+    lcb_cntl_string(instance, "compression_min_size", "1024"); /* greater than size of the value */
+    value = "A big black bug bit a big black bear, made the big black bear bleed blood";
+    compressed = "A big black bug bit a big black bear, made the big black bear bleed blood";
+    scmd = lcb_CMDSTORE();
+    scmd.operation = LCB_UPSERT;
+    LCB_CMD_SET_KEY(&scmd, key.c_str(), key.size());
+    LCB_CMD_SET_VALUE(&scmd, value.c_str(), value.size());
+    cookie = SnappyCookie();
+    lcb_store3(instance, &cookie, &scmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+
+    cookie = SnappyCookie();
+    gcmd = lcb_CMDGET();
+    LCB_CMD_SET_KEY(&gcmd, key.c_str(), key.size());
+    lcb_get3(instance, &cookie, &gcmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+    ASSERT_STREQ(compressed.c_str(), cookie.value.c_str());
+
+    lcb_cntl_string(instance, "compression_min_size", "40"); /* less than size of the value */
+    lcb_cntl_string(instance, "compression_min_ratio", "0.1"); /* expect to reduce size in 10 times */
+    value = "A big black bug bit a big black bear, made the big black bear bleed blood";
+    compressed = "A big black bug bit a big black bear, made the big black bear bleed blood";
+    scmd = lcb_CMDSTORE();
+    scmd.operation = LCB_UPSERT;
+    LCB_CMD_SET_KEY(&scmd, key.c_str(), key.size());
+    LCB_CMD_SET_VALUE(&scmd, value.c_str(), value.size());
+    cookie = SnappyCookie();
+    lcb_store3(instance, &cookie, &scmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+
+    cookie = SnappyCookie();
+    gcmd = lcb_CMDGET();
+    LCB_CMD_SET_KEY(&gcmd, key.c_str(), key.size());
+    lcb_get3(instance, &cookie, &gcmd);
+    lcb_wait(instance);
+    ASSERT_TRUE(cookie.called);
+    ASSERT_EQ(LCB_SUCCESS, cookie.rc);
+    ASSERT_STREQ(compressed.c_str(), cookie.value.c_str());
+}