test: test against legacy redis for redis-clustering gem (#119)

Author: supercaracal

.github/workflows/test.yaml

@@ -97,6 +97,35 @@ jobs:
         run: bundle exec rake test
       - name: Stop containers
         run: docker compose -f $DOCKER_COMPOSE_FILE down
+  legacy-redis:
+    name: Legacy Redis
+    timeout-minutes: 15
+    strategy:
+      fail-fast: false
+    runs-on: ubuntu-latest
+    env:
+      REDIS_VERSION: '5.0.14'
+      DOCKER_COMPOSE_FILE: 'compose.yaml'
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.1'
+          bundler-cache: true
+      - name: Pull Docker images
+        run: docker pull redis:$REDIS_VERSION
+      - name: Run containers
+        run: docker compose -f $DOCKER_COMPOSE_FILE up -d
+      - name: Wait for Redis cluster to be ready
+        run: bundle exec rake wait
+      - name: Print containers
+        run: docker compose -f $DOCKER_COMPOSE_FILE ps
+      - name: Run minitest
+        run: bundle exec rake test
+      - name: Stop containers
+        run: docker compose -f $DOCKER_COMPOSE_FILE down
   cluster-state:
     name: Cluster State
     timeout-minutes: 15

test/redis_client/test_cluster.rb

@@ -63,8 +63,8 @@ def test_blocking_call
         @client.call(*%w[RPUSH foo hello])
         @client.call(*%w[RPUSH foo world])
         wait_for_replication
-        client_side_timeout = 1.0
-        server_side_timeout = 0.5
+        client_side_timeout = TEST_REDIS_MAJOR_VERSION < 6 ? 1.5 : 1.0
+        server_side_timeout = TEST_REDIS_MAJOR_VERSION < 6 ? '1' : '0.5'
         assert_equal(%w[foo world], @client.blocking_call(client_side_timeout, 'BRPOP', 'foo', server_side_timeout), 'Case: 1st')
         assert_equal(%w[foo hello], @client.blocking_call(client_side_timeout, 'BRPOP', 'foo', server_side_timeout), 'Case: 2nd')
         assert_nil(@client.blocking_call(client_side_timeout, 'BRPOP', 'foo', server_side_timeout), 'Case: 3rd')
@@ -129,10 +129,12 @@ def test_pipelined
         wait_for_replication
 
         want = %w[PONG] + (0..9).map(&:to_s) + [%w[list 2]]
+        client_side_timeout = TEST_REDIS_MAJOR_VERSION < 6 ? 1.5 : 1.0
+        server_side_timeout = TEST_REDIS_MAJOR_VERSION < 6 ? '1' : '0.5'
         got = @client.pipelined do |pipeline|
           pipeline.call_once('PING')
           10.times { |i| pipeline.call('GET', "string#{i}") }
-          pipeline.blocking_call(0.2, 'BRPOP', 'list', '0.1')
+          pipeline.blocking_call(client_side_timeout, 'BRPOP', 'list', server_side_timeout)
         end
         assert_equal(want, got)
       end
@@ -162,22 +164,22 @@ def test_close
         assert_nil(@client.close)
       end
 
-      def test_dedicated_commands
+      def test_dedicated_commands # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         10.times { |i| @client.call('SET', "key#{i}", i) }
         wait_for_replication
         [
-          { command: %w[ACL HELP], is_a: Array },
+          { command: %w[ACL HELP], is_a: Array, supported_redis_version: 6 },
           { command: ['WAIT', TEST_REPLICA_SIZE, '1'], is_a: Integer },
           { command: %w[KEYS *], want: (0..9).map { |i| "key#{i}" } },
           { command: %w[DBSIZE], want: (0..9).size },
           { command: %w[SCAN], is_a: Array },
           { command: %w[LASTSAVE], is_a: Array },
           { command: %w[ROLE], is_a: Array },
           { command: %w[CONFIG RESETSTAT], want: 'OK' },
-          { command: %w[CONFIG GET maxmemory], is_a: Hash },
+          { command: %w[CONFIG GET maxmemory], is_a: TEST_REDIS_MAJOR_VERSION < 6 ? Array : Hash },
           { command: %w[CLIENT LIST], is_a: Array },
           { command: %w[CLIENT PAUSE 100], want: 'OK' },
-          { command: %w[CLIENT INFO], is_a: String },
+          { command: %w[CLIENT INFO], is_a: String, supported_redis_version: 6 },
           { command: %w[CLUSTER SET-CONFIG-EPOCH 0], error: ::RedisClient::Cluster::OrchestrationCommandNotSupported },
           { command: %w[CLUSTER SAVECONFIG], want: 'OK' },
           { command: %w[CLUSTER GETKEYSINSLOT 13252 1], want: %w[key0] },
@@ -196,6 +198,8 @@ def test_dedicated_commands
           { command: %w[MULTI], error: ::RedisClient::Cluster::AmbiguousNodeError },
           { command: %w[FLUSHDB], want: 'OK' }
         ].each do |c|
+          next if c.key?(:supported_redis_version) && TEST_REDIS_MAJOR_VERSION < c[:supported_redis_version]
+
           msg = "Case: #{c[:command].join(' ')}"
           got = -> { @client.call(*c[:command]) }
           if c.key?(:error)

test/testing_constants.rb

@@ -21,22 +21,29 @@
 _base_opts = {
   timeout: TEST_TIMEOUT_SEC,
   reconnect_attempts: TEST_RECONNECT_ATTEMPTS
-}.freeze
+}
 
 _ssl_opts = {
   ssl: true,
   ssl_params: TEST_SSL_PARAMS
 }.freeze
 
+_redis_scheme = 'redis'
+
 begin
-  _new_raw_cli.call(**_base_opts).call('PING')
-  TEST_REDIS_SCHEME = 'redis'
+  _tmp_cli = _new_raw_cli.call(**_base_opts)
+  _tmp_cli.call('PING')
+rescue ::RedisClient::UnsupportedServer
+  _base_opts.merge!(protocol: 2)
 rescue ::RedisClient::ConnectionError => e
   raise e if e.message != 'Connection reset by peer'
 
-  TEST_REDIS_SCHEME = 'rediss'
+  _redis_scheme = 'rediss'
+ensure
+  _tmp_cli&.close
 end
 
+TEST_REDIS_SCHEME = _redis_scheme
 TEST_REDIS_SSL = TEST_REDIS_SCHEME == 'rediss'
 TEST_FIXED_HOSTNAME = TEST_REDIS_SSL ? TEST_REDIS_HOST : nil
 
@@ -49,6 +56,11 @@
 TEST_NODE_URIS = TEST_REDIS_PORTS.map { |v| "#{TEST_REDIS_SCHEME}://#{TEST_REDIS_HOST}:#{v}" }.freeze
 TEST_NODE_OPTIONS = TEST_REDIS_PORTS.to_h { |v| ["#{TEST_REDIS_HOST}:#{v}", { host: TEST_REDIS_HOST, port: v }] }.freeze
 
-TEST_GENERIC_OPTIONS = TEST_REDIS_SSL ? _base_opts.merge(_ssl_opts).freeze : _base_opts
+TEST_GENERIC_OPTIONS = (TEST_REDIS_SSL ? _base_opts.merge(_ssl_opts) : _base_opts).freeze
+
+_tmp_cli = _new_raw_cli.call(**TEST_GENERIC_OPTIONS)
+TEST_REDIS_VERSION = _tmp_cli.call('INFO', 'SERVER').split("\r\n").grep(/redis_version.+/).first.split(':')[1]
+TEST_REDIS_MAJOR_VERSION = Integer(TEST_REDIS_VERSION.split('.').first)
+_tmp_cli.close
 
 # rubocop:enable Lint/UnderscorePrefixedVariableName