Add test for resolving a host to an address

The IPv6 change in b146d74 made a bunch of tests fail because they could
not connect to 'localhost'. They could not connect because only the
first result from getaddrinfo(3) was used, which happened to be the IPv6
localhost address. This commit changes those tests to use 127.0.0.1 and
adds a test that explicitly tests that the client can resolve localhost.

Author: pietern

test/commands_on_value_types_test.rb

@@ -99,7 +99,7 @@ def test_flushall
 
   def test_migrate
     redis_mock(:migrate => lambda { |*args| args }) do |redis|
-      options = { :host => "localhost", :port => 1234 }
+      options = { :host => "127.0.0.1", :port => 1234 }
 
       assert_raise(RuntimeError, /host not specified/) do
         redis.migrate("foo", options.reject { |key, _| key == :host })
@@ -114,17 +114,17 @@ def test_migrate
 
       # Test defaults
       actual = redis.migrate("foo", options)
-      expected = ["localhost", "1234", "foo", default_db.to_s, default_timeout.to_s]
+      expected = ["127.0.0.1", "1234", "foo", default_db.to_s, default_timeout.to_s]
       assert_equal expected, actual
 
       # Test db override
       actual = redis.migrate("foo", options.merge(:db => default_db + 1))
-      expected = ["localhost", "1234", "foo", (default_db + 1).to_s, default_timeout.to_s]
+      expected = ["127.0.0.1", "1234", "foo", (default_db + 1).to_s, default_timeout.to_s]
       assert_equal expected, actual
 
       # Test timeout override
       actual = redis.migrate("foo", options.merge(:timeout => default_timeout + 1))
-      expected = ["localhost", "1234", "foo", default_db.to_s, (default_timeout + 1).to_s]
+      expected = ["127.0.0.1", "1234", "foo", default_db.to_s, (default_timeout + 1).to_s]
       assert_equal expected, actual
     end
   end

test/connection_handling_test.rb

@@ -157,7 +157,7 @@ def test_shutdown_with_error_from_multi_exec
 
   def test_slaveof
     redis_mock(:slaveof => lambda { |host, port| "+SLAVEOF #{host} #{port}" }) do |redis|
-      assert_equal "SLAVEOF localhost 6381", redis.slaveof("localhost", 6381)
+      assert_equal "SLAVEOF somehost 6381", redis.slaveof("somehost", 6381)
     end
   end
 

test/distributed_internals_test.rb

@@ -7,32 +7,32 @@ class TestDistributedInternals < Test::Unit::TestCase
   include Helper::Distributed
 
   def test_provides_a_meaningful_inspect
-    nodes = ["redis://localhost:#{PORT}/15", *NODES]
+    nodes = ["redis://127.0.0.1:#{PORT}/15", *NODES]
     redis = Redis::Distributed.new nodes
 
     assert_equal "#<Redis client v#{Redis::VERSION} for #{redis.nodes.map(&:id).join(', ')}>", redis.inspect
   end
 
   def test_default_as_urls
-    nodes = ["redis://localhost:#{PORT}/15", *NODES]
+    nodes = ["redis://127.0.0.1:#{PORT}/15", *NODES]
     redis = Redis::Distributed.new nodes
-    assert_equal ["redis://localhost:#{PORT}/15", *NODES], redis.nodes.map { |node| node.client.id}
+    assert_equal ["redis://127.0.0.1:#{PORT}/15", *NODES], redis.nodes.map { |node| node.client.id}
   end
 
   def test_default_as_config_hashes
-    nodes = [OPTIONS.merge(:host => 'localhost'), OPTIONS.merge(:host => 'localhost', :port => PORT.next)]
+    nodes = [OPTIONS.merge(:host => '127.0.0.1'), OPTIONS.merge(:host => 'somehost', :port => PORT.next)]
     redis = Redis::Distributed.new nodes
-    assert_equal ["redis://localhost:#{PORT}/15","redis://localhost:#{PORT.next}/15"], redis.nodes.map { |node| node.client.id }
+    assert_equal ["redis://127.0.0.1:#{PORT}/15","redis://somehost:#{PORT.next}/15"], redis.nodes.map { |node| node.client.id }
   end
 
   def test_as_mix_and_match
-    nodes = ["redis://localhost:7389/15", OPTIONS.merge(:host => 'localhost'), OPTIONS.merge(:host => 'localhost', :port => PORT.next)]
+    nodes = ["redis://127.0.0.1:7389/15", OPTIONS.merge(:host => 'somehost'), OPTIONS.merge(:host => 'somehost', :port => PORT.next)]
     redis = Redis::Distributed.new nodes
-    assert_equal ["redis://localhost:7389/15", "redis://localhost:#{PORT}/15", "redis://localhost:#{PORT.next}/15"], redis.nodes.map { |node| node.client.id }
+    assert_equal ["redis://127.0.0.1:7389/15", "redis://somehost:#{PORT}/15", "redis://somehost:#{PORT.next}/15"], redis.nodes.map { |node| node.client.id }
   end
 
   def test_override_id
-    nodes = [OPTIONS.merge(:host => 'localhost', :id => "test"), OPTIONS.merge( :host => 'localhost', :port => PORT.next, :id => "test1")]
+    nodes = [OPTIONS.merge(:host => '127.0.0.1', :id => "test"), OPTIONS.merge( :host => 'somehost', :port => PORT.next, :id => "test1")]
     redis = Redis::Distributed.new nodes
     assert_equal redis.nodes.first.client.id, "test"
     assert_equal redis.nodes.last.client.id,  "test1"

test/distributed_key_tags_test.rb

@@ -8,17 +8,17 @@ class TestDistributedKeyTags < Test::Unit::TestCase
   include Helper::Distributed
 
   def test_hashes_consistently
-    r1 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
-    r2 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
-    r3 = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
+    r1 = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
+    r2 = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
+    r3 = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
 
     assert_equal r1.node_for("foo").id, r2.node_for("foo").id
     assert_equal r1.node_for("foo").id, r3.node_for("foo").id
   end
 
   def test_allows_clustering_of_keys
     r = Redis::Distributed.new(NODES)
-    r.add_node("redis://localhost:#{PORT}/14")
+    r.add_node("redis://127.0.0.1:#{PORT}/14")
     r.flushdb
 
     100.times do |i|
@@ -29,7 +29,7 @@ def test_allows_clustering_of_keys
   end
 
   def test_distributes_keys_if_no_clustering_is_used
-    r.add_node("redis://localhost:#{PORT}/14")
+    r.add_node("redis://127.0.0.1:#{PORT}/14")
     r.flushdb
 
     r.set "users:1", 1
@@ -40,7 +40,7 @@ def test_distributes_keys_if_no_clustering_is_used
 
   def test_allows_passing_a_custom_tag_extractor
     r = Redis::Distributed.new(NODES, :tag => /^(.+?):/)
-    r.add_node("redis://localhost:#{PORT}/14")
+    r.add_node("redis://127.0.0.1:#{PORT}/14")
     r.flushdb
 
     100.times do |i|

test/distributed_test.rb

@@ -7,7 +7,7 @@ class TestDistributed < Test::Unit::TestCase
   include Helper::Distributed
 
   def test_handle_multiple_servers
-    @r = Redis::Distributed.new ["redis://localhost:#{PORT}/15", *NODES]
+    @r = Redis::Distributed.new ["redis://127.0.0.1:#{PORT}/15", *NODES]
 
     100.times do |idx|
       @r.set(idx.to_s, "foo#{idx}")
@@ -32,9 +32,9 @@ def test_add_nodes
     assert_equal 10, @r.nodes[0].client.timeout
     assert_equal logger, @r.nodes[0].client.logger
 
-    @r.add_node("redis://localhost:6380/14")
+    @r.add_node("redis://127.0.0.1:6380/14")
 
-    assert_equal "localhost", @r.nodes[1].client.host
+    assert_equal "127.0.0.1", @r.nodes[1].client.host
     assert_equal 6380, @r.nodes[1].client.port
     assert_equal 14, @r.nodes[1].client.db
     assert_equal 10, @r.nodes[1].client.timeout

test/internals_test.rb

@@ -342,4 +342,10 @@ def test_does_not_change_self_client_options
     assert_equal 1, redis.client.options[:db]
     assert_equal "foo", redis.client.options[:scheme]
   end
+
+  def test_resolves_localhost
+    assert_nothing_raised do
+      Redis.new(OPTIONS.merge(:host => 'localhost')).ping
+    end
+  end
 end

test/publish_subscribe_test.rb

@@ -191,7 +191,7 @@ def test_unsubscribe_without_a_subscribe
   def test_subscribe_past_a_timeout
     # For some reason, a thread here doesn't reproduce the issue.
     sleep = %{sleep #{OPTIONS[:timeout] * 2}}
-    publish = %{echo "publish foo bar\r\n" | nc localhost #{OPTIONS[:port]}}
+    publish = %{echo "publish foo bar\r\n" | nc 127.0.0.1 #{OPTIONS[:port]}}
     cmd = [sleep, publish].join("; ")
 
     IO.popen(cmd, "r+") do |pipe|