dalli-elasticache 0.1.1 → 1.0.1

data/spec/config_command_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative 'spec_helper'
+
+describe 'Dalli::Elasticache::AutoDiscovery::ConfigCommand' do
+  let(:host) { Faker::Internet.domain_name(subdomain: true) }
+  let(:port) { rand(1024..16_023) }
+  let(:command) { Dalli::Elasticache::AutoDiscovery::ConfigCommand.new(host, port, engine_version) }
+
+  let(:socket_response_lines) do
+    [
+      "CONFIG cluster 0 142\r\n",
+      "12\r\n",
+      'mycluster.0001.cache.amazonaws.com|10.112.21.1|11211 '\
+      'mycluster.0002.cache.amazonaws.com|10.112.21.2|11211 '\
+      "mycluster.0003.cache.amazonaws.com|10.112.21.3|11211\r\n",
+      "\r\n",
+      "END\r\n"
+    ]
+  end
+
+  let(:expected_nodes) do
+    [
+      Dalli::Elasticache::AutoDiscovery::Node.new('mycluster.0001.cache.amazonaws.com',
+                                                  '10.112.21.1',
+                                                  11_211),
+      Dalli::Elasticache::AutoDiscovery::Node.new('mycluster.0002.cache.amazonaws.com',
+                                                  '10.112.21.2',
+                                                  11_211),
+      Dalli::Elasticache::AutoDiscovery::Node.new('mycluster.0003.cache.amazonaws.com',
+                                                  '10.112.21.3',
+                                                  11_211)
+    ]
+  end
+
+  let(:mock_socket) { instance_double(TCPSocket) }
+
+  before do
+    allow(TCPSocket).to receive(:new).with(host, port).and_return(mock_socket)
+    allow(mock_socket).to receive(:close)
+    allow(mock_socket).to receive(:puts).with(cmd)
+    allow(mock_socket).to receive(:readline).and_return(*socket_response_lines)
+  end
+
+  context 'when the engine_version is 1.4.5' do
+    let(:engine_version) { '1.4.5' } # This is the only pre-1.4.14 version available on AWS
+    let(:cmd) { Dalli::Elasticache::AutoDiscovery::ConfigCommand::LEGACY_CONFIG_COMMAND }
+
+    context 'when the socket returns a valid response' do
+      before do
+        allow(mock_socket).to receive(:readline).and_return(*socket_response_lines)
+      end
+
+      it 'sends the legacy command and returns a ConfigResponse with expected values' do
+        response = command.response
+        expect(response).to be_a Dalli::Elasticache::AutoDiscovery::ConfigResponse
+        expect(response.version).to eq(12)
+        expect(response.nodes).to eq(expected_nodes)
+        expect(mock_socket).to have_received(:close)
+      end
+    end
+  end
+
+  context 'when the engine_version is greater than or equal to 1.4.14' do
+    let(:engine_version) { ['1.4.14', '1.5.6', '1.6.10'].sample }
+    let(:cmd) { Dalli::Elasticache::AutoDiscovery::ConfigCommand::CONFIG_COMMAND }
+
+    context 'when the socket returns a valid response' do
+      before do
+        allow(mock_socket).to receive(:readline).and_return(*socket_response_lines)
+      end
+
+      it 'sends the current command and returns a ConfigResponse with expected values' do
+        response = command.response
+        expect(response).to be_a Dalli::Elasticache::AutoDiscovery::ConfigResponse
+        expect(response.version).to eq(12)
+        expect(response.nodes).to eq(expected_nodes)
+        expect(mock_socket).to have_received(:close)
+      end
+    end
+  end
+
+  context 'when the engine_version is UNKNOWN or some other string' do
+    let(:engine_version) { ['UNKNOWN', SecureRandom.hex(4), nil].sample }
+    let(:cmd) { Dalli::Elasticache::AutoDiscovery::ConfigCommand::CONFIG_COMMAND }
+
+    context 'when the socket returns a valid response' do
+      before do
+        allow(mock_socket).to receive(:readline).and_return(*socket_response_lines)
+      end
+
+      it 'sends the current command and returns a ConfigResponse with expected values' do
+        response = command.response
+        expect(response).to be_a Dalli::Elasticache::AutoDiscovery::ConfigResponse
+        expect(response.version).to eq(12)
+        expect(response.nodes).to eq(expected_nodes)
+        expect(mock_socket).to have_received(:close)
+      end
+    end
+  end
+end

data/spec/config_response_spec.rb

@@ -1,32 +1,36 @@
+# frozen_string_literal: true
+
 require_relative 'spec_helper'
 
 describe 'Dalli::Elasticache::AutoDiscovery::ConfigResponse' do
   let :response do
-    text = "CONFIG cluster 0 141\r\n12\nmycluster.0001.cache.amazonaws.com|10.112.21.1|11211 mycluster.0002.cache.amazonaws.com|10.112.21.2|11211 mycluster.0003.cache.amazonaws.com|10.112.21.3|11211\n\r\n"
+    text = "CONFIG cluster 0 141\r\n12\nmycluster.0001.cache.amazonaws.com|10.112.21.1|11211 "\
+           'mycluster.0002.cache.amazonaws.com|10.112.21.2|11211 '\
+           "mycluster.0003.cache.amazonaws.com|10.112.21.3|11211\n\r\n"
     Dalli::Elasticache::AutoDiscovery::ConfigResponse.new(text)
   end
-  
+
   describe '#version' do
     it 'parses version' do
-      response.version.should == 12
+      expect(response.version).to eq 12
     end
   end
 
   describe '#nodes' do
     it 'parses hosts' do
-      response.nodes.map{|s| s[:host]}.should == [
-        "mycluster.0001.cache.amazonaws.com",
-        "mycluster.0002.cache.amazonaws.com",
-        "mycluster.0003.cache.amazonaws.com"
+      expect(response.nodes.map(&:host)).to eq [
+        'mycluster.0001.cache.amazonaws.com',
+        'mycluster.0002.cache.amazonaws.com',
+        'mycluster.0003.cache.amazonaws.com'
       ]
     end
-  
+
     it 'parses ip addresses' do
-      response.nodes.map{|s| s[:ip]}.should == ["10.112.21.1", "10.112.21.2", "10.112.21.3"]
+      expect(response.nodes.map(&:ip)).to eq ['10.112.21.1', '10.112.21.2', '10.112.21.3']
     end
-  
+
     it 'parses ports' do
-      response.nodes.map{|s| s[:port]}.should == [11211, 11211, 11211]
+      expect(response.nodes.map(&:port)).to eq [11_211, 11_211, 11_211]
     end
   end
 end

data/spec/elasticache_spec.rb

@@ -1,45 +1,128 @@
+# frozen_string_literal: true
+
 require_relative 'spec_helper'
 
 describe 'Dalli::ElastiCache::Endpoint' do
-  let(:cache) do
-    options = {
-      :expires_in => 24*60*60,
-      :namespace => "my_app",
-      :compress => true
+  let(:dalli_options) do
+    {
+      expires_in: 24 * 60 * 60,
+      namespace: 'my_app',
+      compress: true
     }
-    Dalli::ElastiCache.new("my-cluster.cfg.use1.cache.amazonaws.com:11211", options)
   end
-  
+
+  let(:host) { 'my-cluster.cfg.use1.cache.amazonaws.com' }
+  let(:port) { 11_211 }
+  let(:config_endpoint) { "#{host}:#{port}" }
+  let(:cache) do
+    Dalli::ElastiCache.new(config_endpoint, dalli_options)
+  end
+
+  let(:config_text) do
+    "CONFIG cluster 0 141\r\n12\nmycluster.0001.cache.amazonaws.com|10.112.21.1|11211 "\
+      'mycluster.0002.cache.amazonaws.com|10.112.21.2|11211 '\
+      "mycluster.0003.cache.amazonaws.com|10.112.21.3|11211\n\r\n"
+  end
+  let(:response) { Dalli::Elasticache::AutoDiscovery::ConfigResponse.new(config_text) }
+
   describe '.new' do
     it 'builds endpoint' do
-      cache.endpoint.host.should == "my-cluster.cfg.use1.cache.amazonaws.com"
-      cache.endpoint.port.should == 11211
+      expect(cache.endpoint.host).to eq 'my-cluster.cfg.use1.cache.amazonaws.com'
+      expect(cache.endpoint.port).to eq 11_211
     end
-    
+
     it 'stores Dalli options' do
-      cache.options[:expires_in].should == 24*60*60
-      cache.options[:namespace].should == "my_app"
-      cache.options[:compress].should == true
+      expect(cache.options[:expires_in]).to eq 24 * 60 * 60
+      expect(cache.options[:namespace]).to eq 'my_app'
+      expect(cache.options[:compress]).to eq true
     end
   end
-  
+
   describe '#client' do
-    it 'builds with node list'
-    it 'builds with options'
+    let(:client) { cache.client }
+    let(:stub_endpoint) { Dalli::Elasticache::AutoDiscovery::Endpoint.new(config_endpoint) }
+    let(:mock_dalli) { instance_double(Dalli::Client) }
+
+    before do
+      allow(Dalli::Elasticache::AutoDiscovery::Endpoint).to receive(:new)
+        .with(config_endpoint).and_return(stub_endpoint)
+      allow(stub_endpoint).to receive(:config).and_return(response)
+      allow(Dalli::Client).to receive(:new)
+        .with(['mycluster.0001.cache.amazonaws.com:11211',
+               'mycluster.0002.cache.amazonaws.com:11211',
+               'mycluster.0003.cache.amazonaws.com:11211'],
+              dalli_options).and_return(mock_dalli)
+    end
+
+    it 'builds with node list and dalli options' do
+      expect(client).to eq(mock_dalli)
+      expect(stub_endpoint).to have_received(:config)
+      expect(Dalli::Client).to have_received(:new)
+        .with(['mycluster.0001.cache.amazonaws.com:11211',
+               'mycluster.0002.cache.amazonaws.com:11211',
+               'mycluster.0003.cache.amazonaws.com:11211'],
+              dalli_options)
+    end
   end
-  
+
   describe '#servers' do
-    it 'lists addresses and ports'
+    let(:stub_endpoint) { Dalli::Elasticache::AutoDiscovery::Endpoint.new(config_endpoint) }
+
+    before do
+      allow(Dalli::Elasticache::AutoDiscovery::Endpoint).to receive(:new)
+        .with(config_endpoint).and_return(stub_endpoint)
+      allow(stub_endpoint).to receive(:config).and_return(response)
+    end
+
+    it 'lists addresses and ports' do
+      expect(cache.servers).to eq ['mycluster.0001.cache.amazonaws.com:11211',
+                                   'mycluster.0002.cache.amazonaws.com:11211',
+                                   'mycluster.0003.cache.amazonaws.com:11211']
+      expect(stub_endpoint).to have_received(:config)
+      expect(Dalli::Elasticache::AutoDiscovery::Endpoint).to have_received(:new).with(config_endpoint)
+    end
   end
-  
+
   describe '#version' do
+    let(:mock_config) { instance_double(Dalli::Elasticache::AutoDiscovery::ConfigResponse) }
+    let(:version) { rand(1..20) }
+
+    before do
+      allow(cache.endpoint).to receive(:config).and_return(mock_config)
+      allow(mock_config).to receive(:version).and_return(version)
+    end
+
+    it 'delegates the call to the config on the endpoint' do
+      expect(cache.version).to eq(version)
+      expect(cache.endpoint).to have_received(:config)
+      expect(mock_config).to have_received(:version)
+    end
   end
-  
+
   describe '#engine_version' do
+    let(:engine_version) { [Gem::Version.new('1.6.13'), Gem::Version.new('1.4.14')].sample }
+
+    before do
+      allow(cache.endpoint).to receive(:engine_version).and_return(engine_version)
+    end
+
+    it 'delegates the call to the endpoint' do
+      expect(cache.engine_version).to eq(engine_version)
+      expect(cache.endpoint).to have_received(:engine_version)
+    end
   end
-  
+
   describe '#refresh' do
-    it 'clears endpoint configuration'
+    it 'clears endpoint configuration' do
+      stale_endpoint = cache.endpoint
+      expect(cache.refresh.endpoint).not_to eq stale_endpoint
+    end
+
+    it 'builds endpoint with same configuration' do
+      stale_endpoint = cache.endpoint
+      cache.refresh
+      expect(cache.endpoint.host).to eq(stale_endpoint.host)
+      expect(cache.endpoint.port).to eq(stale_endpoint.port)
+    end
   end
-  
 end

data/spec/endpoint_spec.rb

@@ -1,16 +1,87 @@
+# frozen_string_literal: true
+
 require_relative 'spec_helper'
 
 describe 'Dalli::Elasticache::AutoDiscovery::Endpoint' do
   let(:endpoint) do
-    Dalli::Elasticache::AutoDiscovery::Endpoint.new("my-cluster.cfg.use1.cache.amazonaws.com:11211")
+    Dalli::Elasticache::AutoDiscovery::Endpoint.new(arg_string)
   end
-  
+
   describe '.new' do
-    it 'parses host' do
-      endpoint.host.should == "my-cluster.cfg.use1.cache.amazonaws.com"
+    context 'when the string includes both host and port' do
+      let(:arg_string) { 'my-cluster.cfg.use1.cache.amazonaws.com:12345' }
+
+      it 'parses host' do
+        expect(endpoint.host).to eq 'my-cluster.cfg.use1.cache.amazonaws.com'
+      end
+
+      it 'parses port' do
+        expect(endpoint.port).to eq 12_345
+      end
+    end
+
+    context 'when the string includes only a host' do
+      let(:arg_string) { 'example.cfg.use1.cache.amazonaws.com' }
+
+      it 'parses host' do
+        expect(endpoint.host).to eq 'example.cfg.use1.cache.amazonaws.com'
+      end
+
+      it 'parses port' do
+        expect(endpoint.port).to eq 11_211
+      end
+    end
+
+    context 'when the string is nil' do
+      let(:arg_string) { nil }
+
+      it 'raises ArgumentError' do
+        expect do
+          endpoint
+        end.to raise_error ArgumentError, "Unable to parse configuration endpoint address - #{arg_string}"
+      end
     end
-    it 'parses port' do
-      endpoint.port.should == 11211
+
+    context 'when the string contains disallowed characters in the host' do
+      let(:arg_string) { 'my-cluster?.cfg.use1.cache.amazonaws.com:12345' }
+
+      it 'raises ArgumentError' do
+        expect do
+          endpoint
+        end.to raise_error ArgumentError, "Unable to parse configuration endpoint address - #{arg_string}"
+      end
+    end
+
+    context 'when the string contains disallowed characters in the port' do
+      let(:arg_string) { 'my-cluster.cfg.use1.cache.amazonaws.com:1234a5' }
+
+      it 'raises ArgumentError' do
+        expect do
+          endpoint
+        end.to raise_error ArgumentError, "Unable to parse configuration endpoint address - #{arg_string}"
+      end
+    end
+
+    context 'when the string contains trailing characters' do
+      let(:arg_string) { 'my-cluster.cfg.use1.cache.amazonaws.com:12345abcd' }
+
+      it 'raises ArgumentError' do
+        expect do
+          endpoint
+        end.to raise_error ArgumentError, "Unable to parse configuration endpoint address - #{arg_string}"
+      end
+    end
+
+    context 'when the host in the string includes an underscore' do
+      let(:arg_string) { 'my_cluster.cfg.use1.cache.amazonaws.com:12345' }
+
+      it 'parses host' do
+        expect(endpoint.host).to eq 'my_cluster.cfg.use1.cache.amazonaws.com'
+      end
+
+      it 'parses port' do
+        expect(endpoint.port).to eq 12_345
+      end
     end
   end
 end

data/spec/node_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'spec_helper'
+
+describe 'Dalli::Elasticache::AutoDiscovery::Node' do
+  context 'when comparing with equals' do
+    let(:host1) { Faker::Internet.domain_name(subdomain: true) }
+    let(:ip1) { Faker::Internet.public_ip_v4_address }
+    let(:port1) { rand(1024..16_023) }
+    let(:host2) { Faker::Internet.domain_name(subdomain: true) }
+    let(:ip2) { Faker::Internet.public_ip_v4_address }
+    let(:port2) { rand(1024..16_023) }
+
+    let(:node1a) { Dalli::Elasticache::AutoDiscovery::Node.new(host1, ip1, port1) }
+    let(:node1b) { Dalli::Elasticache::AutoDiscovery::Node.new(host1, ip1, port1) }
+
+    let(:node_with_different_host) { Dalli::Elasticache::AutoDiscovery::Node.new(host2, ip1, port1) }
+    let(:node_with_different_ip) { Dalli::Elasticache::AutoDiscovery::Node.new(host1, ip2, port1) }
+    let(:node_with_different_port) { Dalli::Elasticache::AutoDiscovery::Node.new(host1, ip1, port2) }
+
+    it 'is equal to a value with the same values' do
+      expect(node1a).to eq(node1b)
+      expect(node1a.eql?(node1b)).to eq(true)
+    end
+
+    it 'is not equal to a value with any differing values' do
+      expect(node1a).not_to eq(node_with_different_host)
+      expect(node1a.eql?(node_with_different_host)).to eq(false)
+      expect(node1a).not_to eq(node_with_different_ip)
+      expect(node1a.eql?(node_with_different_ip)).to eq(false)
+      expect(node1a).not_to eq(node_with_different_port)
+      expect(node1a.eql?(node_with_different_port)).to eq(false)
+    end
+  end
+
+  context 'when used as a hash key' do
+    let(:host1) { Faker::Internet.domain_name(subdomain: true) }
+    let(:ip1) { Faker::Internet.public_ip_v4_address }
+    let(:port1) { rand(1024..16_023) }
+    let(:host2) { Faker::Internet.domain_name(subdomain: true) }
+    let(:ip2) { Faker::Internet.public_ip_v4_address }
+    let(:port2) { rand(1024..16_023) }
+
+    let(:node1a) { Dalli::Elasticache::AutoDiscovery::Node.new(host1, ip1, port1) }
+    let(:node1b) { Dalli::Elasticache::AutoDiscovery::Node.new(host1, ip1, port1) }
+
+    let(:node_with_different_host) { Dalli::Elasticache::AutoDiscovery::Node.new(host2, ip1, port1) }
+    let(:node_with_different_ip) { Dalli::Elasticache::AutoDiscovery::Node.new(host1, ip2, port1) }
+    let(:node_with_different_port) { Dalli::Elasticache::AutoDiscovery::Node.new(host1, ip1, port2) }
+
+    let(:test_val) { 'abcd' }
+    let(:test_hash) do
+      { node1a => test_val }
+    end
+
+    it 'computes the same hash key' do
+      expect(node1a.hash).to eq(node1b.hash)
+    end
+
+    it 'matches when an equivalent object is used' do
+      expect(test_hash.key?(node1b)).to eq(true)
+    end
+
+    it 'does not match when an non-equivalent object is used' do
+      expect(test_hash.key?(node_with_different_host)).to eq(false)
+      expect(test_hash.key?(node_with_different_ip)).to eq(false)
+      expect(test_hash.key?(node_with_different_port)).to eq(false)
+    end
+  end
+
+  describe '#to_s' do
+    let(:host) { Faker::Internet.domain_name(subdomain: true) }
+    let(:ip) { Faker::Internet.public_ip_v4_address }
+    let(:port) { rand(1024..16_023) }
+
+    let(:node) { Dalli::Elasticache::AutoDiscovery::Node.new(host, ip, port) }
+
+    it 'returns the expected string value' do
+      expect(node.to_s).to eq("#{host}:#{port}")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,12 +1,9 @@
-require "bundler/setup"
+# frozen_string_literal: true
 
-require "dalli/elasticache"
+require 'bundler/setup'
 
-RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :should
-  end
-  config.mock_with :rspec do |c|
-    c.syntax = :should
-  end
-end
+require 'dalli/elasticache'
+require 'securerandom'
+require 'faker'
+
+RSpec.configure

data/spec/stats_command_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'spec_helper'
+
+describe 'Dalli::Elasticache::AutoDiscovery::StatsCommand' do
+  let(:host) { 'example.com' }
+  let(:port) { 12_345 }
+  let(:command) { Dalli::Elasticache::AutoDiscovery::StatsCommand.new(host, port) }
+  let(:engine_version) { ['1.4.5', '1.4.14', '1.5.6', '1.6.10'].sample }
+  let(:cmd) { "stats\r\n" }
+
+  let(:socket_response_lines) do
+    [
+      "STAT pid 1\r\n",
+      "STAT uptime 68717\r\n",
+      "STAT time 1398885375\r\n",
+      "STAT version #{engine_version}\r\n",
+      "STAT libevent 1.4.13-stable\r\n",
+      "STAT pointer_size 64\r\n",
+      "STAT rusage_user 0.136008\r\n",
+      "STAT rusage_system 0.424026\r\n",
+      "STAT curr_connections 5\r\n",
+      "STAT total_connections 1159\r\n",
+      "STAT connection_structures 6\r\n",
+      "STAT reserved_fds 5\r\n",
+      "STAT cmd_get 0\r\n",
+      "STAT cmd_set 0\r\n",
+      "STAT cmd_flush 0\r\n",
+      "STAT cmd_touch 0\r\n",
+      "STAT cmd_config_get 4582\r\n",
+      "STAT cmd_config_set 2\r\n",
+      "STAT get_hits 0\r\n",
+      "STAT get_misses 0\r\n",
+      "STAT delete_misses 0\r\n",
+      "STAT delete_hits 0\r\n",
+      "STAT incr_misses 0\r\n",
+      "STAT incr_hits 0\r\n",
+      "STAT decr_misses 0\r\n",
+      "STAT decr_hits 0\r\n",
+      "STAT cas_misses 0\r\n",
+      "STAT cas_hits 0\r\n",
+      "STAT cas_badval 0\r\n",
+      "STAT touch_hits 0\r\n",
+      "STAT touch_misses 0\r\n",
+      "STAT auth_cmds 0\r\n",
+      "STAT auth_errors 0\r\n",
+      "STAT bytes_read 189356\r\n",
+      "STAT bytes_written 2906615\r\n",
+      "STAT limit_maxbytes 209715200\r\n",
+      "STAT accepting_conns 1\r\n",
+      "STAT listen_disabled_num 0\r\n",
+      "STAT threads 1\r\n",
+      "STAT conn_yields 0\r\n",
+      "STAT curr_config 1\r\n",
+      "STAT hash_power_level 16\r\n",
+      "STAT hash_bytes 524288\r\n",
+      "STAT hash_is_expanding 0\r\n",
+      "STAT expired_unfetched 0\r\n",
+      "STAT evicted_unfetched 0\r\n",
+      "STAT bytes 0\r\n",
+      "STAT curr_items 0\r\n",
+      "STAT total_items 0\r\n",
+      "STAT evictions 0\r\n",
+      "STAT reclaimed 0\r\n",
+      "END\r\n"
+    ]
+  end
+
+  let(:mock_socket) { instance_double(TCPSocket) }
+
+  before do
+    allow(TCPSocket).to receive(:new).with(host, port).and_return(mock_socket)
+    allow(mock_socket).to receive(:close)
+    allow(mock_socket).to receive(:puts).with(cmd)
+    allow(mock_socket).to receive(:readline).and_return(*socket_response_lines)
+  end
+
+  context 'when the socket returns a valid response' do
+    before do
+      allow(mock_socket).to receive(:readline).and_return(*socket_response_lines)
+    end
+
+    it 'sends the command and parses out the engine version' do
+      response = command.response
+      expect(response.engine_version).to eq(engine_version)
+      expect(mock_socket).to have_received(:close)
+      expect(mock_socket).to have_received(:puts).with(cmd)
+    end
+  end
+end