counting_semaphore 0.1.0 → 0.2.0

data/test/counting_semaphore/redis_semaphore_test.rb

@@ -17,11 +17,6 @@ class RedisSemaphoreTest < Minitest::Test
     end
   end
 
-  def test_initializes_with_correct_capacity
-    semaphore = CountingSemaphore::RedisSemaphore.new(5, "test_namespace")
-    assert_equal 5, semaphore.instance_variable_get(:@capacity)
-  end
-
   def test_capacity_attribute_returns_the_initialized_capacity
     semaphore = CountingSemaphore::RedisSemaphore.new(10, "test_namespace")
     assert_equal 10, semaphore.capacity
@@ -158,7 +153,7 @@ class RedisSemaphoreTest < Minitest::Test
         results << "client2_attempting_5_tokens"
       end
 
-      semaphore2.with_lease(5, timeout_seconds: 2) do
+      semaphore2.with_lease(5, timeout: 2) do
         results << "client2_acquired_5_tokens"
         sleep 0.05
         results << "client2_releasing_5_tokens"
@@ -264,7 +259,7 @@ class RedisSemaphoreTest < Minitest::Test
       )
 
       begin
-        semaphore2.with_lease(1, timeout_seconds: 0.5) do
+        semaphore2.with_lease(1, timeout: 0.5) do
           # This should not execute
         end
       rescue CountingSemaphore::LeaseTimeout
@@ -326,7 +321,7 @@ class RedisSemaphoreTest < Minitest::Test
       )
 
       begin
-        semaphore2.with_lease(1, timeout_seconds: 0.5) do
+        semaphore2.with_lease(1, timeout: 0.5) do
           # This should not execute
         end
       rescue CountingSemaphore::LeaseTimeout => e
@@ -401,7 +396,7 @@ class RedisSemaphoreTest < Minitest::Test
       )
 
       begin
-        semaphore2.with_lease(timeout_seconds: 0.5) do  # Uses default token count of 1
+        semaphore2.with_lease(timeout: 0.5) do  # Uses default token count of 1
           # This should not execute
         end
       rescue CountingSemaphore::LeaseTimeout
@@ -417,6 +412,37 @@ class RedisSemaphoreTest < Minitest::Test
     assert client2_timeout_raised, "Expected client2 to raise LeaseTimeout but it didn't"
   end
 
+  def test_with_lease_yields_lease_to_block
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(5, namespace, redis: Redis.new(db: REDIS_DB))
+    yielded_lease = nil
+
+    result = semaphore.with_lease(3) do |lease|
+      yielded_lease = lease
+      "block result"
+    end
+
+    assert_equal "block result", result
+    refute_nil yielded_lease
+    assert_instance_of CountingSemaphore::Lease, yielded_lease
+    assert_equal 3, yielded_lease.permits
+    assert_equal semaphore, yielded_lease.semaphore
+    assert_equal 5, semaphore.available_permits
+  end
+
+  def test_with_lease_yields_nil_for_zero_permits
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(5, namespace, redis: Redis.new(db: REDIS_DB))
+    yielded_lease = :not_set
+
+    semaphore.with_lease(0) do |lease|
+      yielded_lease = lease
+    end
+
+    assert_nil yielded_lease
+    assert_equal 5, semaphore.available_permits
+  end
+
   def test_currently_leased_returns_zero_initially
     semaphore = CountingSemaphore::RedisSemaphore.new(5, "test_namespace")
     assert_equal 0, semaphore.currently_leased
@@ -483,4 +509,392 @@ class RedisSemaphoreTest < Minitest::Test
     assert_equal 0, semaphore1.currently_leased
     assert_equal 0, semaphore2.currently_leased
   end
+
+  # Tests for concurrent-ruby compatible API
+
+  def test_acquire_and_release_single_permit
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(3, namespace, redis: Redis.new(db: REDIS_DB))
+
+    assert_equal 3, semaphore.available_permits
+
+    lease = semaphore.acquire(1)
+    assert_equal 2, semaphore.available_permits
+    semaphore.release(lease)
+    assert_equal 3, semaphore.available_permits
+  end
+
+  def test_acquire_and_release_multiple_permits
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(5, namespace, redis: Redis.new(db: REDIS_DB))
+
+    lease = semaphore.acquire(3)
+    assert_equal 2, semaphore.available_permits
+    semaphore.release(lease)
+    assert_equal 5, semaphore.available_permits
+  end
+
+  def test_acquire_defaults_to_one_permit
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(3, namespace, redis: Redis.new(db: REDIS_DB))
+
+    lease = semaphore.acquire
+    assert_equal 2, semaphore.available_permits
+
+    semaphore.release(lease)
+    assert_equal 3, semaphore.available_permits
+  end
+
+  test_with_timeout "acquire blocks until permits available" do
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    completed_order = []
+    mutex = Mutex.new
+
+    # Thread 1: Acquires permits and holds them
+    thread1 = Thread.new do
+      semaphore1 = CountingSemaphore::RedisSemaphore.new(2, namespace, redis: Redis.new(db: REDIS_DB))
+      lease1 = semaphore1.acquire(2)
+      mutex.synchronize { completed_order << :thread1_acquired }
+      sleep(0.2) # Hold briefly
+      semaphore1.release(lease1)
+      mutex.synchronize { completed_order << :thread1_released }
+    end
+
+    sleep(0.1) # Let thread1 acquire
+
+    # Thread 2: Tries to acquire - should block until thread1 releases
+    thread2 = Thread.new do
+      semaphore2 = CountingSemaphore::RedisSemaphore.new(2, namespace, redis: Redis.new(db: REDIS_DB))
+      mutex.synchronize { completed_order << :thread2_attempting }
+      lease2 = semaphore2.acquire(1)
+      mutex.synchronize { completed_order << :thread2_acquired }
+      semaphore2.release(lease2)
+    end
+
+    thread1.join
+    thread2.join
+
+    # Thread2 should acquire after thread1 releases
+    assert_equal [:thread1_acquired, :thread2_attempting, :thread1_released, :thread2_acquired], completed_order
+  end
+
+  def test_acquire_raises_error_for_invalid_permits
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(5, namespace, redis: Redis.new(db: REDIS_DB))
+
+    assert_raises(ArgumentError) do
+      semaphore.acquire(0)
+    end
+
+    assert_raises(ArgumentError) do
+      semaphore.acquire(-1)
+    end
+  end
+
+  def test_acquire_raises_error_for_permits_exceeding_capacity
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(3, namespace, redis: Redis.new(db: REDIS_DB))
+
+    assert_raises(ArgumentError) do
+      semaphore.acquire(5)
+    end
+  end
+
+  def test_release_raises_error_for_invalid_lease
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(5, namespace, redis: Redis.new(db: REDIS_DB))
+
+    assert_raises(NoMethodError) do
+      semaphore.release("not a lease")
+    end
+
+    assert_raises(NoMethodError) do
+      semaphore.release(nil)
+    end
+  end
+
+  def test_release_raises_error_for_lease_from_different_semaphore
+    namespace1 = "test_semaphore_#{SecureRandom.uuid}"
+    namespace2 = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore1 = CountingSemaphore::RedisSemaphore.new(5, namespace1, redis: Redis.new(db: REDIS_DB))
+    semaphore2 = CountingSemaphore::RedisSemaphore.new(5, namespace2, redis: Redis.new(db: REDIS_DB))
+
+    lease = semaphore1.acquire(1)
+
+    assert_raises(ArgumentError) do
+      semaphore2.release(lease)
+    end
+
+    semaphore1.release(lease)
+  end
+
+  def test_try_acquire_succeeds_when_permits_available
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(3, namespace, redis: Redis.new(db: REDIS_DB))
+
+    lease = semaphore.try_acquire(2)
+    refute_nil lease
+    assert_equal 1, semaphore.available_permits
+
+    semaphore.release(lease)
+  end
+
+  def test_try_acquire_fails_when_permits_not_available
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(2, namespace, redis: Redis.new(db: REDIS_DB))
+
+    lease1 = semaphore.acquire(2)
+    lease2 = semaphore.try_acquire(1)
+    assert_nil lease2
+
+    semaphore.release(lease1)
+  end
+
+  def test_try_acquire_with_nil_timeout_returns_quickly
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(1, namespace, redis: Redis.new(db: REDIS_DB))
+
+    lease1 = semaphore.acquire(1)
+    start_time = Time.now
+
+    lease2 = semaphore.try_acquire(1, timeout: nil)
+    elapsed_time = Time.now - start_time
+
+    assert_nil lease2
+    assert elapsed_time < 0.5, "Should return quickly, took #{elapsed_time}s"
+
+    semaphore.release(lease1)
+  end
+
+  test_with_timeout "try_acquire with timeout waits for permits" do
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+
+    # Thread 1: Holds the permit temporarily
+    thread1 = Thread.new do
+      semaphore1 = CountingSemaphore::RedisSemaphore.new(1, namespace, redis: Redis.new(db: REDIS_DB))
+      lease1 = semaphore1.acquire(1)
+      sleep(0.3)
+      semaphore1.release(lease1)
+    end
+
+    sleep(0.1) # Let thread1 acquire
+
+    # Thread 2: Tries to acquire with timeout - should eventually succeed
+    lease2 = nil
+    elapsed_time = 0
+    thread2 = Thread.new do
+      semaphore2 = CountingSemaphore::RedisSemaphore.new(1, namespace, redis: Redis.new(db: REDIS_DB))
+      start_time = Time.now
+      lease2 = semaphore2.try_acquire(1, timeout: 1.0)
+      elapsed_time = Time.now - start_time
+      semaphore2.release(lease2) if lease2
+    end
+
+    thread1.join
+    thread2.join
+
+    refute_nil lease2
+    assert elapsed_time >= 0.2, "Should have waited for release"
+    assert elapsed_time < 1.0, "Should not have waited full timeout"
+  end
+
+  def test_try_acquire_with_timeout_fails_when_timeout_exceeded
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(1, namespace, redis: Redis.new(db: REDIS_DB))
+
+    lease1 = semaphore.acquire(1)
+    start_time = Time.now
+    lease2 = semaphore.try_acquire(1, timeout: 0.3)
+    elapsed_time = Time.now - start_time
+
+    assert_nil lease2
+    assert elapsed_time >= 0.3, "Should have waited for timeout"
+
+    semaphore.release(lease1)
+  end
+
+  def test_try_acquire_defaults_to_one_permit
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(3, namespace, redis: Redis.new(db: REDIS_DB))
+
+    lease = semaphore.try_acquire
+    refute_nil lease
+    assert_equal 2, semaphore.available_permits
+
+    semaphore.release(lease)
+  end
+
+  def test_try_acquire_raises_error_for_invalid_permits
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(5, namespace, redis: Redis.new(db: REDIS_DB))
+
+    assert_raises(ArgumentError) do
+      semaphore.try_acquire(0)
+    end
+
+    assert_raises(ArgumentError) do
+      semaphore.try_acquire(-1)
+    end
+  end
+
+  def test_available_permits_returns_correct_count
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(5, namespace, redis: Redis.new(db: REDIS_DB))
+
+    assert_equal 5, semaphore.available_permits
+
+    lease1 = semaphore.acquire(2)
+    assert_equal 3, semaphore.available_permits
+
+    lease2 = semaphore.acquire(1)
+    assert_equal 2, semaphore.available_permits
+
+    # Release all acquired permits
+    semaphore.release(lease2)
+    semaphore.release(lease1)
+    assert_equal 5, semaphore.available_permits
+  end
+
+  test_with_timeout "available_permits with concurrent operations" do
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(5, namespace, redis: Redis.new(db: REDIS_DB))
+
+    threads = 3.times.map do
+      Thread.new do
+        lease = semaphore.acquire(1)
+        sleep(0.1)
+        semaphore.release(lease)
+      end
+    end
+
+    sleep(0.05) # Let threads acquire
+    available = semaphore.available_permits
+
+    # Should have 2 or fewer available (3 threads acquired)
+    assert available <= 2, "Expected <= 2 available, got #{available}"
+
+    threads.each(&:join)
+
+    # All should be available now
+    assert_equal 5, semaphore.available_permits
+  end
+
+  def test_drain_permits_acquires_all_available
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(5, namespace, redis: Redis.new(db: REDIS_DB))
+
+    drained_lease = semaphore.drain_permits
+
+    refute_nil drained_lease
+    assert_equal 5, drained_lease.permits
+    assert_equal 0, semaphore.available_permits
+
+    # Release them back
+    semaphore.release(drained_lease)
+    assert_equal 5, semaphore.available_permits
+  end
+
+  def test_drain_permits_acquires_only_available
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(5, namespace, redis: Redis.new(db: REDIS_DB))
+
+    lease1 = semaphore.acquire(2)
+    drained_lease = semaphore.drain_permits
+
+    refute_nil drained_lease
+    assert_equal 3, drained_lease.permits
+    assert_equal 0, semaphore.available_permits
+
+    # Release them back
+    semaphore.release(drained_lease)
+    semaphore.release(lease1)
+    assert_equal 5, semaphore.available_permits
+  end
+
+  def test_drain_permits_returns_nil_when_none_available
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(3, namespace, redis: Redis.new(db: REDIS_DB))
+
+    lease = semaphore.acquire(3)
+    drained_lease = semaphore.drain_permits
+
+    assert_nil drained_lease
+    assert_equal 0, semaphore.available_permits
+    semaphore.release(lease)
+  end
+
+  test_with_timeout "acquire release maintain correct count under stress" do
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(10, namespace, redis: Redis.new(db: REDIS_DB))
+    iterations = 10
+
+    threads = 5.times.map do
+      Thread.new do
+        iterations.times do
+          lease = semaphore.acquire(1)
+          # No sleep - stress test
+          semaphore.release(lease)
+        end
+      end
+    end
+
+    threads.each(&:join)
+
+    # All permits should be available
+    assert_equal 10, semaphore.available_permits
+    assert_equal 0, semaphore.currently_leased
+  end
+
+  test_with_timeout "concurrent ruby api compatibility pattern" do
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore = CountingSemaphore::RedisSemaphore.new(3, namespace, redis: Redis.new(db: REDIS_DB))
+    results = []
+    mutex = Mutex.new
+
+    threads = 5.times.map do |i|
+      Thread.new do
+        if (lease = semaphore.try_acquire(1, timeout: 1.0))
+          begin
+            mutex.synchronize { results << i }
+            sleep(0.1)
+          ensure
+            semaphore.release(lease)
+          end
+        end
+      end
+    end
+
+    threads.each(&:join)
+
+    # All threads should complete without hanging
+    assert results.length > 0, "Expected at least some threads to succeed"
+    assert results.length <= 5, "Expected no more threads than total (5)"
+    assert_equal 3, semaphore.available_permits
+  end
+
+  test_with_timeout "distributed acquire and release across multiple instances" do
+    namespace = "test_semaphore_#{SecureRandom.uuid}"
+    semaphore1 = CountingSemaphore::RedisSemaphore.new(5, namespace, redis: Redis.new(db: REDIS_DB))
+    semaphore2 = CountingSemaphore::RedisSemaphore.new(5, namespace, redis: Redis.new(db: REDIS_DB))
+
+    # Acquire from first instance
+    lease1 = semaphore1.acquire(2)
+    assert_equal 3, semaphore1.available_permits
+    assert_equal 3, semaphore2.available_permits
+
+    # Acquire from second instance
+    lease2 = semaphore2.acquire(2)
+    assert_equal 1, semaphore1.available_permits
+    assert_equal 1, semaphore2.available_permits
+
+    # Release from first instance
+    semaphore1.release(lease1)
+    assert_equal 3, semaphore1.available_permits
+    assert_equal 3, semaphore2.available_permits
+
+    # Release from second instance
+    semaphore2.release(lease2)
+    assert_equal 5, semaphore1.available_permits
+    assert_equal 5, semaphore2.available_permits
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: counting_semaphore
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Julik Tarkhanov
 bindir: exe
 cert_chain: []
-date: 2025-10-17 00:00:00.000000000 Z
+date: 2025-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -79,6 +79,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: sord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.0
 description: Provides both local (in-process) and shared (Redis-based) counting semaphores
   for controlling concurrent access to resources
 email:
@@ -93,7 +107,6 @@ files:
 - ".ruby-version"
 - AGENTS.md
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
@@ -101,8 +114,10 @@ files:
 - lib/counting_semaphore/local_semaphore.rb
 - lib/counting_semaphore/null_logger.rb
 - lib/counting_semaphore/redis_semaphore.rb
-- lib/counting_semaphore/shared_semaphore.rb
 - lib/counting_semaphore/version.rb
+- lib/counting_semaphore/with_lease_support.rb
+- rbi/counting_semaphore.rbi
+- sig/counting_semaphore.rbs
 - test/counting_semaphore/local_semaphore_test.rb
 - test/counting_semaphore/redis_semaphore_test.rb
 - test/test_helper.rb

data/Gemfile.lock

@@ -1,76 +0,0 @@
-PATH
-  remote: .
-  specs:
-    counting_semaphore (0.1.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    ast (2.4.3)
-    connection_pool (2.5.4)
-    json (2.15.1)
-    language_server-protocol (3.17.0.5)
-    lint_roller (1.1.0)
-    minitest (5.26.0)
-    parallel (1.27.0)
-    parser (3.3.9.0)
-      ast (~> 2.4.1)
-      racc
-    prism (1.6.0)
-    racc (1.8.1)
-    rainbow (3.1.1)
-    rake (13.3.0)
-    redis (5.4.1)
-      redis-client (>= 0.22.0)
-    redis-client (0.26.1)
-      connection_pool
-    regexp_parser (2.11.3)
-    rubocop (1.80.2)
-      json (~> 2.3)
-      language_server-protocol (~> 3.17.0.2)
-      lint_roller (~> 1.1.0)
-      parallel (~> 1.10)
-      parser (>= 3.3.0.2)
-      rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 2.9.3, < 3.0)
-      rubocop-ast (>= 1.46.0, < 2.0)
-      ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 2.4.0, < 4.0)
-    rubocop-ast (1.47.1)
-      parser (>= 3.3.7.2)
-      prism (~> 1.4)
-    rubocop-performance (1.25.0)
-      lint_roller (~> 1.1)
-      rubocop (>= 1.75.0, < 2.0)
-      rubocop-ast (>= 1.38.0, < 2.0)
-    ruby-progressbar (1.13.0)
-    standard (1.51.1)
-      language_server-protocol (~> 3.17.0.2)
-      lint_roller (~> 1.0)
-      rubocop (~> 1.80.2)
-      standard-custom (~> 1.0.0)
-      standard-performance (~> 1.8)
-    standard-custom (1.0.2)
-      lint_roller (~> 1.0)
-      rubocop (~> 1.50)
-    standard-performance (1.8.0)
-      lint_roller (~> 1.1)
-      rubocop-performance (~> 1.25.0)
-    unicode-display_width (3.2.0)
-      unicode-emoji (~> 4.1)
-    unicode-emoji (4.1.0)
-
-PLATFORMS
-  arm64-darwin-24
-  ruby
-
-DEPENDENCIES
-  connection_pool (~> 2.4)
-  counting_semaphore!
-  minitest (~> 5.0)
-  rake (~> 13.0)
-  redis (~> 5.0)
-  standard (>= 1.35.1)
-
-BUNDLED WITH
-   2.6.9