Dynamically choose available ports in tests

test/benchmark_test.rb

@@ -23,7 +23,7 @@ def profile(&block)
     @value = []
     @marshalled = Marshal.dump(@value)
 
-    @port = 23_417
+    @port = find_available_port
     @servers = ["127.0.0.1:#{@port}", "localhost:#{@port}"]
     @key1 = 'Short'
     @key2 = 'Sym1-2-3::45' * 8

test/helpers/memcached.rb

@@ -46,13 +46,14 @@ def memcached(protocol, port_or_socket, args = '', client_options = {}, terminat
     # but sets terminate_process to false ensuring that the process persists
     # past execution of the block argument.
     # rubocop:disable Metrics/ParameterLists
-    def memcached_persistent(protocol = :binary, port_or_socket = 21_345, args = '', client_options = {}, &block)
+    def memcached_persistent(protocol = :binary, port_or_socket = find_available_port, args = '', client_options = {},
+                             &block)
       memcached(protocol, port_or_socket, args, client_options, terminate_process: false, &block)
     end
     # rubocop:enable Metrics/ParameterLists
 
     # Launches a persistent memcached process, configured to use SSL
-    def memcached_ssl_persistent(protocol = :binary, port_or_socket = rand(21_397..21_896), &block)
+    def memcached_ssl_persistent(protocol = :binary, port_or_socket = find_available_port, &block)
       memcached_persistent(protocol,
                            port_or_socket,
                            CertificateGenerator.ssl_args,
@@ -67,7 +68,7 @@ def memcached_kill(port_or_socket)
     end
 
     # Launches a persistent memcached process, configured to use SASL authentication
-    def memcached_sasl_persistent(port_or_socket = 21_398, &block)
+    def memcached_sasl_persistent(port_or_socket = find_available_port, &block)
       memcached_persistent(:binary, port_or_socket, '-S', sasl_credentials, &block)
     end
 
@@ -95,5 +96,9 @@ def kill_process(pid)
     def supports_fork?
       Process.respond_to?(:fork)
     end
+
+    def find_available_port
+      MemcachedMock.find_available_port
+    end
   end
 end

test/integration/test_authentication.rb

@@ -7,7 +7,7 @@
     let(:username) { SecureRandom.hex(5) }
     it 'raises an error if the username is set' do
       err = assert_raises Dalli::DalliError do
-        memcached_persistent(:meta, 21_345, '', username: username) do |dc|
+        memcached_persistent(:meta, find_available_port, '', username: username) do |dc|
           dc.flush
           dc.set('key1', 'abcd')
         end

test/integration/test_compressor.rb

@@ -17,22 +17,23 @@ def self.decompress(data)
   MemcachedManager.supported_protocols.each do |p|
     describe "using the #{p} protocol" do
       it 'default to Dalli::Compressor' do
-        memcached(p, 29_199) do |dc|
+        memcached(p, find_available_port) do |dc|
           dc.set 1, 2
 
           assert_equal Dalli::Compressor, dc.instance_variable_get(:@ring).servers.first.compressor
         end
       end
 
       it 'support a custom compressor' do
-        memcached(p, 29_199) do |_dc|
-          memcache = Dalli::Client.new('127.0.0.1:29199', { compressor: NoopCompressor })
+        port = find_available_port
+        memcached(p, port) do |_dc|
+          memcache = Dalli::Client.new("127.0.0.1:#{port}", { compressor: NoopCompressor })
           memcache.set 1, 2
           begin
             assert_equal NoopCompressor,
                          memcache.instance_variable_get(:@ring).servers.first.compressor
 
-            memcached(p, 19_127) do |newdc|
+            memcached(p, port) do |newdc|
               assert newdc.set('string-test', 'a test string')
               assert_equal('a test string', newdc.get('string-test'))
             end
@@ -42,8 +43,9 @@ def self.decompress(data)
 
       describe 'GzipCompressor' do
         it 'compress and uncompress data using Zlib::GzipWriter/Reader' do
-          memcached(p, 19_127) do |_dc|
-            memcache = Dalli::Client.new('127.0.0.1:19127', { compress: true, compressor: Dalli::GzipCompressor })
+          port = find_available_port
+          memcached(p, port) do |_dc|
+            memcache = Dalli::Client.new("127.0.0.1:#{port}", { compress: true, compressor: Dalli::GzipCompressor })
             data = (0...1025).map { rand(65..90).chr }.join
 
             assert memcache.set('test', data)

test/integration/test_failover.rb

@@ -33,8 +33,7 @@
 
       describe 'assuming some bad servers' do
         it 'silently reconnect if server hiccups' do
-          server_port = 30_124
-          memcached_persistent(p, server_port) do |dc, port|
+          memcached_persistent(p, find_available_port) do |dc, port|
             dc.set 'foo', 'bar'
             foo = dc.get 'foo'
 
@@ -52,11 +51,8 @@
         end
 
         it 'reconnects if server idles the connection' do
-          port1 = 32_112
-          port2 = 37_887
-
-          memcached(p, port1, '-o idle_timeout=1') do |_, first_port|
-            memcached(p, port2, '-o idle_timeout=1') do |_, second_port|
+          memcached(p, find_available_port, '-o idle_timeout=1') do |_, first_port|
+            memcached(p, find_available_port, '-o idle_timeout=1') do |_, second_port|
               dc = Dalli::Client.new ["localhost:#{first_port}", "localhost:#{second_port}"]
               dc.set 'foo', 'bar'
               dc.set 'foo2', 'bar2'
@@ -75,10 +71,8 @@
         end
 
         it 'handle graceful failover' do
-          port1 = 31_777
-          port2 = 32_113
-          memcached_persistent(p, port1) do |_first_dc, first_port|
-            memcached_persistent(p, port2) do |_second_dc, second_port|
+          memcached_persistent(p, find_available_port) do |_first_dc, first_port|
+            memcached_persistent(p, find_available_port) do |_second_dc, second_port|
               dc = Dalli::Client.new ["localhost:#{first_port}", "localhost:#{second_port}"]
               dc.set 'foo', 'bar'
               foo = dc.get 'foo'
@@ -102,10 +96,8 @@
         end
 
         it 'handle them gracefully in get_multi' do
-          port1 = 32_971
-          port2 = 34_312
-          memcached_persistent(p, port1) do |_first_dc, first_port|
-            memcached(p, port2) do |_second_dc, second_port|
+          memcached_persistent(p, find_available_port) do |_first_dc, first_port|
+            memcached(p, find_available_port) do |_second_dc, second_port|
               dc = Dalli::Client.new ["localhost:#{first_port}", "localhost:#{second_port}"]
               dc.set 'a', 'a1'
               result = dc.get_multi ['a']
@@ -122,10 +114,8 @@
         end
 
         it 'handle graceful failover in get_multi' do
-          port1 = 34_541
-          port2 = 33_044
-          memcached_persistent(p, port1) do |_first_dc, first_port|
-            memcached_persistent(p, port2) do |_second_dc, second_port|
+          memcached_persistent(p, find_available_port) do |_first_dc, first_port|
+            memcached_persistent(p, find_available_port) do |_second_dc, second_port|
               dc = Dalli::Client.new ["localhost:#{first_port}", "localhost:#{second_port}"]
               dc.set 'foo', 'foo1'
               dc.set 'bar', 'bar1'
@@ -151,10 +141,8 @@
         end
 
         it 'stats it still properly report' do
-          port1 = 34_547
-          port2 = 33_219
-          memcached_persistent(p, port1) do |_first_dc, first_port|
-            memcached_persistent(p, port2) do |_second_dc, second_port|
+          memcached_persistent(p, find_available_port) do |_first_dc, first_port|
+            memcached_persistent(p, find_available_port) do |_second_dc, second_port|
               dc = Dalli::Client.new ["localhost:#{first_port}", "localhost:#{second_port}"]
               result = dc.stats
 

test/integration/test_network.rb

@@ -122,7 +122,7 @@
 
       it 'handles timeout error during pipelined get' do
         with_nil_logger do
-          memcached(p, 19_191) do |dc|
+          memcached(p, find_available_port) do |dc|
             dc.send(:ring).server_for_key('abc').sock.stub(:write, proc { raise Timeout::Error }) do
               assert_empty dc.get_multi(['abc'])
             end
@@ -132,7 +132,7 @@
 
       it 'handles asynchronous Thread#raise' do
         with_nil_logger do
-          memcached(p, 19_191) do |dc|
+          memcached(p, find_available_port) do |dc|
             10.times do |i|
               thread = Thread.new do
                 loop do
@@ -156,7 +156,7 @@
 
       it 'handles asynchronous Thread#raise during pipelined get' do
         with_nil_logger do
-          memcached(p, 19_191) do |dc|
+          memcached(p, find_available_port) do |dc|
             10.times do |i|
               expected_response = 100.times.to_h { |x| ["key:#{i}:#{x}", x.to_s] }
               expected_response.each do |key, val|
@@ -185,7 +185,7 @@
 
       it 'handles asynchronous Thread#kill' do
         with_nil_logger do
-          memcached(p, 19_191) do |dc|
+          memcached(p, find_available_port) do |dc|
             10.times do |i|
               thread = Thread.new do
                 loop do
@@ -209,7 +209,7 @@
 
       it 'handles asynchronous Thread#kill during pipelined get' do
         with_nil_logger do
-          memcached(p, 19_191) do |dc|
+          memcached(p, find_available_port) do |dc|
             10.times do |i|
               expected_response = 100.times.to_h { |x| ["key:#{i}:#{x}", x.to_s] }
               expected_response.each do |key, val|

test/integration/test_operations.rb

@@ -221,7 +221,9 @@
         end
 
         it 'supports with nil values when cache_nils: true' do
-          memcached_persistent(p, 21_345, '', cache_nils: true) do |dc|
+          port = find_available_port
+
+          memcached_persistent(p, port, '', cache_nils: true) do |dc|
             dc.flush
 
             dc.set('fetch_key', nil)
@@ -230,7 +232,7 @@
             assert_nil res
           end
 
-          memcached_persistent(p, 21_345, '', cache_nils: false) do |dc|
+          memcached_persistent(p, port, '', cache_nils: false) do |dc|
             dc.flush
             dc.set('fetch_key', nil)
             executed = false

test/integration/test_serializer.rb

@@ -7,21 +7,21 @@
   MemcachedManager.supported_protocols.each do |p|
     describe "using the #{p} protocol" do
       it 'defaults to Marshal' do
-        memcached(p, 29_198) do |dc|
+        memcached(p, find_available_port) do |dc|
           dc.set 1, 2
 
           assert_equal Marshal, dc.instance_variable_get(:@ring).servers.first.serializer
         end
       end
 
       it 'supports a custom serializer' do
-        memcached(p, 29_198) do |_dc, port|
+        memcached(p, find_available_port) do |_dc, port|
           memcache = Dalli::Client.new("127.0.0.1:#{port}", serializer: JSON)
           memcache.set 1, 2
           begin
             assert_equal JSON, memcache.instance_variable_get(:@ring).servers.first.serializer
 
-            memcached(p, 21_956) do |newdc|
+            memcached(p, find_available_port) do |newdc|
               assert newdc.set('json_test', { 'foo' => 'bar' })
               assert_equal({ 'foo' => 'bar' }, newdc.get('json_test'))
             end

test/protocol/test_server_config_parser.rb

@@ -4,7 +4,7 @@
 
 describe Dalli::Protocol::ServerConfigParser do
   describe 'parse' do
-    let(:port) { rand(9999..99_999) }
+    let(:port) { find_available_port }
     let(:weight) { rand(1..5) }
 
     describe 'when the string is not an memcached URI' do
@@ -90,7 +90,7 @@
     describe 'when the string is a memcached URI' do
       let(:user) { SecureRandom.hex(5) }
       let(:password) { SecureRandom.hex(5) }
-      let(:port) { rand(15_000..16_023) }
+      let(:port) { find_available_port }
       let(:hostname) { "a#{SecureRandom.hex(3)}.b#{SecureRandom.hex(3)}.com" }
 
       describe 'when the URI is properly formed and includes all values' do

test/test_rack_session.rb

@@ -8,7 +8,7 @@
 require 'rack/mock'
 describe Rack::Session::Dalli do
   before do
-    @port = 19_129
+    @port = find_available_port
     memcached_persistent(:binary, @port)
     Rack::Session::Dalli::DEFAULT_DALLI_OPTIONS[:memcache_server] = "localhost:#{@port}"
 

test/test_ring.rb

@@ -43,9 +43,10 @@ def weight
       end
 
       it "return the server when it's alive" do
-        servers = ['localhost:19191']
+        port = find_available_port
+        servers = ["localhost:#{find_available_port}"]
         ring = Dalli::Ring.new(servers, Dalli::Protocol::Binary, {})
-        memcached(:binary, 19_191) do |mc|
+        memcached(:binary, port) do |mc|
           ring = mc.send(:ring)
 
           assert_equal ring.servers.first.port, ring.server_for_key('test').port
@@ -63,9 +64,10 @@ def weight
       end
 
       it 'return an alive server when at least one is alive' do
-        servers = ['localhost:12346', 'localhost:19191']
+        port = find_available_port
+        servers = ['localhost:12346', "localhost:#{port}"]
         ring = Dalli::Ring.new(servers, Dalli::Protocol::Binary, {})
-        memcached(:binary, 19_191) do |mc|
+        memcached(:binary, port) do |mc|
           ring = mc.send(:ring)
 
           assert_equal ring.servers.first.port, ring.server_for_key('test').port
@@ -74,13 +76,16 @@ def weight
     end
 
     it 'detect when a dead server is up again' do
-      memcached(:binary, 19_997) do
+      first_port = find_available_port
+      second_port = find_available_port
+      memcached(:binary, first_port) do
         down_retry_delay = 0.5
-        dc = Dalli::Client.new(['localhost:19997', 'localhost:19998'], down_retry_delay: down_retry_delay)
+        dc = Dalli::Client.new(["localhost:#{first_port}", "localhost:#{second_port}"],
+                               down_retry_delay: down_retry_delay)
 
         assert_equal 1, dc.stats.values.compact.count
 
-        memcached(:binary, 19_998) do
+        memcached(:binary, second_port) do
           assert_equal 2, dc.stats.values.compact.count
         end
       end

test/utils/memcached_mock.rb

@@ -12,7 +12,7 @@ module MemcachedMock
                       f.close
                       f.path)
 
-  def self.start(port = 19_123)
+  def self.start(port = find_available_port)
     server = TCPServer.new('localhost', port)
     session = server.accept
     yield(session)
@@ -29,9 +29,17 @@ def self.start_unix(path = UNIX_SOCKET_PATH)
     yield(session)
   end
 
-  def self.delayed_start(port = 19_123, wait = 1)
+  def self.delayed_start(port = find_available_port, wait = 1)
     server = TCPServer.new('localhost', port)
     sleep wait
     yield(server)
   end
+
+  def self.find_available_port
+    socket = Socket.new(:INET, :STREAM, 0)
+    socket.bind(Addrinfo.tcp('127.0.0.1', 0))
+    port = socket.local_address.ip_port
+    socket.close
+    port
+  end
 end