test/test_pool.rb in random-port-0.5.1 vs test/test_pool.rb in random-port-0.6.0

@@ -21,90 +21,111 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
 require 'minitest/autorun'
+require 'threads'
 require_relative '../lib/random-port/pool'
 
 # Pool test.
 # Author:: Yegor Bugayenko ([e-mail])
 # Copyright:: Copyright (c) 2018 Yegor Bugayenko
 # License:: MIT
-module RandomPort
-  class TestAmount < Minitest::Test
-    def test_acquires_and_releases
-      pool = Pool.new
-      port = pool.acquire
-      assert(!port.nil?)
-      assert(port.positive?)
-      pool.release(port)
-    end
+class RandomPort::TestPool < Minitest::Test
+  def test_acquires_and_releases
+    pool = RandomPort::Pool.new
+    port = pool.acquire
+    server = TCPServer.new(port)
+    server.close
+    assert(!port.nil?)
+    assert(port.positive?)
+    pool.release(port)
+  end
 
-    def test_acquires_and_releases_three_ports
-      pool = Pool.new(limit: 3)
-      assert_equal(0, pool.size)
-      ports = pool.acquire(3, timeout: 16)
-      assert_equal(3, pool.size)
-      assert_equal(3, ports.count)
-      pool.release(ports)
-      assert_equal(0, pool.size)
+  def test_acquires_and_releases_three_ports
+    pool = RandomPort::Pool.new(limit: 3)
+    assert_equal(0, pool.size)
+    ports = pool.acquire(3, timeout: 16)
+    ports.each do |p|
+      server = TCPServer.new(p)
+      server.close
     end
+    assert_equal(3, pool.size)
+    assert_equal(3, ports.count)
+    pool.release(ports)
+    assert_equal(0, pool.size)
+  end
 
-    def test_acquires_and_releases_three_ports_in_block
-      pool = Pool.new(limit: 3)
-      assert_equal(0, pool.size)
-      pool.acquire(3, timeout: 16) do |ports|
-        assert(ports.is_a?(Array))
-        assert_equal(3, ports.count)
-        assert_equal(3, pool.size)
+  def test_acquires_and_releases_three_ports_in_block
+    pool = RandomPort::Pool.new(limit: 3)
+    assert_equal(0, pool.size)
+    pool.acquire(3, timeout: 16) do |ports|
+      assert(ports.is_a?(Array))
+      assert_equal(3, ports.count)
+      assert_equal(3, pool.size)
+      ports.each do |p|
+        server = TCPServer.new(p)
+        server.close
       end
-      assert_equal(0, pool.size)
     end
+    assert_equal(0, pool.size)
+  end
 
-    def test_acquires_and_releases_in_block
-      result = Pool.new.acquire do |port|
-        assert(!port.nil?)
-        assert(port.positive?)
-        123
-      end
-      assert_equal(123, result)
+  def test_acquires_and_releases_in_block
+    result = RandomPort::Pool.new.acquire do |port|
+      assert(!port.nil?)
+      assert(port.positive?)
+      123
     end
+    assert_equal(123, result)
+  end
 
-    def test_acquires_and_releases_safely
-      pool = Pool.new
-      assert_raises do
-        pool.acquire do
-          raise 'Itended'
+  def test_acquires_and_releases_in_threads
+    pool = RandomPort::Pool.new
+    Threads.new(100).assert do
+      pool.acquire(5) do |ports|
+        ports.each do |p|
+          server = TCPServer.new(p)
+          server.close
         end
       end
-      assert(pool.count.zero?)
     end
+  end
 
-    def test_acquires_and_releases_from_singleton
-      Pool::SINGLETON.acquire do |port|
-        assert(!port.nil?)
-        assert(port.positive?)
+  def test_acquires_and_releases_safely
+    pool = RandomPort::Pool.new
+    assert_raises do
+      pool.acquire do
+        raise 'Itended'
       end
     end
+    assert(pool.count.zero?)
+  end
 
-    def test_acquires_unique_numbers
-      total = 25
-      numbers = (0..total - 1).map { Pool::SINGLETON.acquire }
-      assert_equal(total, numbers.uniq.count)
+  def test_acquires_and_releases_from_singleton
+    RandomPort::Pool::SINGLETON.acquire do |port|
+      assert(!port.nil?)
+      assert(port.positive?)
     end
+  end
 
-    def test_raises_when_too_many
-      pool = Pool.new(limit: 1)
-      pool.acquire
-      assert_raises Pool::Timeout do
-        pool.acquire(timeout: 0.1)
-      end
-    end
+  def test_acquires_unique_numbers
+    total = 25
+    numbers = (0..total - 1).map { RandomPort::Pool::SINGLETON.acquire }
+    assert_equal(total, numbers.uniq.count)
+  end
 
-    def test_acquires_unique_numbers_in_no_sync_mode
-      total = 25
-      pool = Pool.new(sync: false)
-      numbers = (0..total - 1).map { pool.acquire }
-      assert_equal(total, numbers.uniq.count)
+  def test_raises_when_too_many
+    pool = RandomPort::Pool.new(limit: 1)
+    pool.acquire
+    assert_raises RandomPort::Pool::Timeout do
+      pool.acquire(timeout: 0.1)
     end
+  end
+
+  def test_acquires_unique_numbers_in_no_sync_mode
+    total = 25
+    pool = RandomPort::Pool.new(sync: false)
+    numbers = (0..total - 1).map { pool.acquire }
+    assert_equal(total, numbers.uniq.count)
   end
 end