Add some test cases (#23)

Author: supercaracal

README.md

@@ -3,12 +3,82 @@
 
 Redis Cluster Client
 ===============================================================================
+This library is a client for Redis cluster.
+It depends on [redis-client](https://github.com/redis-rb/redis-client).
+So it would be better to read `redis-client` documents first.
 
-TODO
+## Installation
+```ruby
+gem 'redis-cluster-client'
+```
+
+## Initialization
+| key | type | default | description |
+| --- | --- |
+| `nodes` | `String` or `Array<String, Hash>` | `['redis://127.0.0.1:6379]` | node addresses for startup connection |
+| `replica` | Boolean | `false` | `true` if client use scale read feature |
+| `fixed_hostname` | `String` | `nil` | specify if client connects to cluster with SSL and single endpoint |
+
+Also, [the other generic options](https://github.com/redis-rb/redis-client#configuration) can be passed.
+
+```ruby
+# The following examples are Docker containers on localhost.
+# The client first attempts to connect to redis://127.0.0.1:6379 internally.
+
+# To connect to primary nodes only
+RedisClient.cluster.new_client
+#=> #<RedisClient::Cluster 172.20.0.2:6379, 172.20.0.6:6379, 172.20.0.7:6379>
+
+# To connect to all nodes and to use scale reading feature
+RedisClient.cluster(replica: true).new_client
+#=> #<RedisClient::Cluster 172.20.0.2:6379, 172.20.0.3:6379, 172.20.0.4:6379, 172.20.0.5:6379, 172.20.0.6:6379, 172.20.0.7:6379>
+
+# With generic options for redis-client
+RedisClient.cluster(timeout: 3.0).new_client
+```
+
+```ruby
+# To connect with subset nodes for startup
+RedisClient.cluster(nodes: %w[redis://node1:6379 redis://node2:6379]).new_client
+```
 
 ```ruby
-cli = RedisClient.cluster(nodes: %w[redis://127.0.0.1:6379]).new_client
+# To connect with single endpoint
+RedisClient.cluster(nodes: 'redis://endpoint.example.com:6379').new_client
+```
 
-cli.call('PING')
-#=> PONG
+```ruby
+# To connect with single endpoint and SSL
+RedisClient.cluster(nodes: 'rediss://endpoint.example.com:6379', fixed_hostname: 'endpoint.example.com').new_client
 ```
+
+## Interfaces
+The following methods are able to be used like `redis-client`.
+* `#call`
+* `#call_once`
+* `#blocking_call`
+* `#scan`
+* `#sscan`
+* `#hscan`
+* `#zscan`
+* `#pipelined`
+* `#pubsub`
+* `#close`
+
+The other methods are not implemented because the client cannot operate with cluster mode.
+`#pipelined` method splits and sends commands to each node and aggregates replies.
+
+## Multiple keys and CROSSSLOT error
+A part of commands can be passed multiple keys. But it has a constraint the keys are in the same hash slot.
+The following error occurs because keys must be in the same hash slot and not just the same node.
+
+```ruby
+RedisClient.cluster.new_client.call('MGET', 'key1', 'key2', 'key3')
+#=> CROSSSLOT Keys in request don't hash to the same slot (RedisClient::CommandError)
+```
+
+## Connection pooling
+TODO
+
+## Connection drivers
+TODO

lib/redis_client/cluster.rb

@@ -20,19 +20,19 @@ def initialize(client)
       end
 
       def call(*command, **kwargs)
-        node_key = @client.send(:find_node_key, command, primary_only: true)
+        node_key = @client.send(:find_node_key, *command, primary_only: true)
         @grouped[node_key] += [[@size, :call, command, kwargs]]
         @size += 1
       end
 
       def call_once(*command, **kwargs)
-        node_key = @client.send(:find_node_key, command, primary_only: true)
+        node_key = @client.send(:find_node_key, *command, primary_only: true)
         @grouped[node_key] += [[@size, :call_once, command, kwargs]]
         @size += 1
       end
 
       def blocking_call(timeout, *command, **kwargs)
-        node_key = @client.send(:find_node_key, command, primary_only: true)
+        node_key = @client.send(:find_node_key, *command, primary_only: true)
         @grouped[node_key] += [[@size, :blocking_call, timeout, command, kwargs]]
         @size += 1
       end
@@ -66,6 +66,14 @@ def execute # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Met
     end
 
     ZERO_CURSOR_FOR_SCAN = '0'
+    CMD_SCAN = 'SCAN'
+    CMD_SSCAN = 'SSCAN'
+    CMD_HSCAN = 'HSCAN'
+    CMD_ZSCAN = 'ZSCAN'
+    CMD_ASKING = 'ASKING'
+    REPLY_OK = 'OK'
+    REPLY_MOVED = 'MOVED'
+    REPLY_ASK = 'ASK'
 
     def initialize(config, pool: nil, **kwargs)
       @config = config.dup
@@ -97,35 +105,27 @@ def scan(*args, **kwargs, &block)
 
       cursor = ZERO_CURSOR_FOR_SCAN
       loop do
-        cursor, keys = _scan('SCAN', cursor, *args, **kwargs)
+        cursor, keys = _scan(CMD_SCAN, cursor, *args, **kwargs)
         keys.each(&block)
         break if cursor == ZERO_CURSOR_FOR_SCAN
       end
     end
 
     def sscan(key, *args, **kwargs, &block)
-      node = assign_node('SSCAN', key)
+      node = assign_node(CMD_SSCAN, key)
       try_send(node, :sscan, key, *args, **kwargs, &block)
     end
 
     def hscan(key, *args, **kwargs, &block)
-      node = assign_node('HSCAN', key)
+      node = assign_node(CMD_HSCAN, key)
       try_send(node, :hscan, key, *args, **kwargs, &block)
     end
 
     def zscan(key, *args, **kwargs, &block)
-      node = assign_node('ZSCAN', key)
+      node = assign_node(CMD_ZSCAN, key)
       try_send(node, :zscan, key, *args, **kwargs, &block)
     end
 
-    def mset
-      # TODO: impl
-    end
-
-    def mget
-      # TODO: impl
-    end
-
     def pipelined
       pipeline = ::RedisClient::Cluster::Pipeline.new(self)
       yield pipeline
@@ -138,15 +138,6 @@ def pubsub
       # TODO: impl
     end
 
-    def size
-      # TODO: impl
-    end
-
-    def with(options = {})
-      # TODO: impl
-    end
-    alias then with
-
     def close
       @node.each(&:close)
       nil
@@ -253,17 +244,17 @@ def send_pubsub_command(method, *command, **kwargs, &block) # rubocop:disable Me
     def try_send(node, method, *args, retry_count: 3, **kwargs, &block) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       node.send(method, *args, **kwargs, &block)
     rescue ::RedisClient::CommandError => e
-      if e.message.start_with?('MOVED')
+      if e.message.start_with?(REPLY_MOVED)
         raise if retry_count <= 0
 
         node = assign_redirection_node(e.message)
         retry_count -= 1
         retry
-      elsif e.message.start_with?('ASK')
+      elsif e.message.start_with?(REPLY_ASK)
         raise if retry_count <= 0
 
         node = assign_asking_node(e.message)
-        node.call('ASKING')
+        node.call(CMD_ASKING)
         retry_count -= 1
         retry
       else
@@ -309,11 +300,11 @@ def assign_asking_node(err_msg)
     end
 
     def assign_node(*command)
-      node_key = find_node_key(command)
+      node_key = find_node_key(*command)
       find_node(node_key)
     end
 
-    def find_node_key(command, primary_only: false)
+    def find_node_key(*command, primary_only: false)
       key = @command.extract_first_key(command)
       return if key.empty?
 

lib/redis_client/cluster/node_key.rb

@@ -19,7 +19,7 @@ def split(node_key)
         pos = node_key&.rindex(DELIMITER, -1)
         return [node_key, nil] if pos.nil?
 
-        [node_key[0, pos], node_key[pos + 1, node_key.size - pos - 1]]
+        [node_key[0, pos], node_key[(pos + 1)..]]
       end
 
       def build_from_uri(uri)