redis: basic integration test for redis_proxy

bazel/envoy_build_system.bzl

@@ -443,7 +443,8 @@ def envoy_cc_test(
         args = [],
         shard_count = None,
         coverage = True,
-        local = False):
+        local = False,
+        size = "medium"):
     test_lib_tags = []
     if coverage:
         test_lib_tags.append("coverage_test_lib")
@@ -472,6 +473,7 @@ def envoy_cc_test(
         tags = tags + ["coverage_test"],
         local = local,
         shard_count = shard_count,
+        size = size,
     )
 
 # Envoy C++ related test infrastructure (that want gtest, gmock, but may be

test/config/utility.cc

@@ -41,6 +41,17 @@ const std::string ConfigHelper::BASE_CONFIG = R"EOF(
         port_value: 0
 )EOF";
 
+const std::string ConfigHelper::REDIS_PROXY_CONFIG = BASE_CONFIG + R"EOF(
+    filter_chains:
+      filters:
+        name: envoy.redis_proxy
+        config:
+          stat_prefix: redis_stats
+          cluster: cluster_0
+          settings: 
+            op_timeout: 5s
+)EOF";
+
 const std::string ConfigHelper::TCP_PROXY_CONFIG = BASE_CONFIG + R"EOF(
     filter_chains:
       filters:

test/config/utility.h

@@ -72,6 +72,8 @@ class ConfigHelper {
   // A basic configuration (admin port, cluster_0, one listener) with no network filters.
   static const std::string BASE_CONFIG;
 
+  // A basic configuration for redis server proxying.
+  static const std::string REDIS_PROXY_CONFIG;
   // A basic configuration for L4 proxying.
   static const std::string TCP_PROXY_CONFIG;
   // A basic configuration for L7 proxying.

test/integration/BUILD

@@ -574,6 +574,19 @@ envoy_cc_test(
     ],
 )
 
+envoy_cc_test(
+    name = "redis_proxy_integration_test",
+    size = "small",
+    srcs = [
+        "redis_proxy_integration_test.cc",
+        "redis_proxy_integration_test.h",
+    ],
+    deps = [
+        ":integration_lib",
+        "//source/extensions/filters/network/redis_proxy:config",
+    ],
+)
+
 envoy_cc_test(
     name = "tcp_proxy_integration_test",
     srcs = [

test/integration/redis_proxy_integration_test.cc

@@ -0,0 +1,83 @@
+#include "test/integration/redis_proxy_integration_test.h"
+
+#include <sstream>
+#include <vector>
+
+#include "extensions/filters/network/redis_proxy/command_splitter_impl.h"
+
+namespace RedisCommon = Envoy::Extensions::NetworkFilters::Common::Redis;
+namespace RedisCmdSplitter = Envoy::Extensions::NetworkFilters::RedisProxy::CommandSplitter;
+
+namespace Envoy {
+namespace {
+
+std::string makeBulkStringArray(std::vector<std::string>&& command_strings) {
+  std::stringstream result;
+
+  result << "*" << command_strings.size() << "\r\n";
+  for (uint64_t i = 0; i < command_strings.size(); i++) {
+    result << "$" << command_strings[i].size() << "\r\n";
+    result << command_strings[i] << "\r\n";
+  }
+
+  return result.str();
+}
+
+INSTANTIATE_TEST_SUITE_P(IpVersions, RedisProxyIntegrationTest,
+                         testing::ValuesIn(TestEnvironment::getIpVersionsForTest()),
+                         TestUtility::ipTestParamsToString);
+
+void RedisProxyIntegrationTest::initialize() {
+  config_helper_.renameListener("redis_proxy");
+  BaseIntegrationTest::initialize();
+}
+
+TEST_P(RedisProxyIntegrationTest, SimpleRequestAndResponse) {
+  initialize();
+  IntegrationTcpClientPtr tcp_client = makeTcpConnection(lookupPort("redis_proxy"));
+
+  std::string client_to_proxy = makeBulkStringArray({"get", "foo"});
+  std::string proxy_to_server;
+
+  ASSERT_TRUE(client_to_proxy.size() > 0);
+  ASSERT_TRUE(client_to_proxy.find("get") != std::string::npos);
+  ASSERT_TRUE(client_to_proxy.find("foo") != std::string::npos);
+  tcp_client->write(client_to_proxy);
+
+  FakeRawConnectionPtr fake_upstream_connection;
+  ASSERT_TRUE(fake_upstreams_[0]->waitForRawConnection(fake_upstream_connection));
+  ASSERT_TRUE(fake_upstream_connection->waitForData(client_to_proxy.size(), &proxy_to_server));
+  ASSERT_EQ(client_to_proxy, proxy_to_server);
+
+  std::string server_to_proxy = "$3\r\nbar\r\n"; // bulkstring reply of "bar"
+
+  ASSERT_TRUE(fake_upstream_connection->write(server_to_proxy));
+  tcp_client->waitForData(server_to_proxy);
+  ASSERT_EQ(server_to_proxy, tcp_client->data());
+
+  tcp_client->close();
+  ASSERT_TRUE(fake_upstream_connection->close());
+}
+
+TEST_P(RedisProxyIntegrationTest, InvalidRequest) {
+  initialize();
+  IntegrationTcpClientPtr tcp_client = makeTcpConnection(lookupPort("redis_proxy"));
+
+  std::string client_to_proxy = makeBulkStringArray({"foo"});
+
+  ASSERT_TRUE(client_to_proxy.size() > 0);
+  ASSERT_TRUE(client_to_proxy.find("foo") != std::string::npos);
+  tcp_client->write(client_to_proxy);
+
+  std::stringstream error_response;
+  error_response << "-" << RedisCmdSplitter::Response::get().InvalidRequest << "\r\n";
+  std::string proxy_to_client = error_response.str();
+
+  tcp_client->waitForData(proxy_to_client);
+  ASSERT_EQ(proxy_to_client, tcp_client->data());
+
+  tcp_client->close();
+}
+
+} // namespace
+} // namespace Envoy

test/integration/redis_proxy_integration_test.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "test/integration/integration.h"
+
+#include "gtest/gtest.h"
+
+namespace Envoy {
+namespace {
+class RedisProxyIntegrationTest : public testing::TestWithParam<Network::Address::IpVersion>,
+                                  public BaseIntegrationTest {
+public:
+  RedisProxyIntegrationTest() : BaseIntegrationTest(GetParam(), ConfigHelper::REDIS_PROXY_CONFIG) {}
+
+  ~RedisProxyIntegrationTest() override {
+    test_server_.reset();
+    fake_upstreams_.clear();
+  }
+
+  void initialize() override;
+};
+
+} // namespace
+} // namespace Envoy