semian 0.6.0 → 0.6.1

data/test/redis_test.rb

@@ -1,237 +0,0 @@
-require 'test_helper'
-
-class TestRedis < Minitest::Test
-  ERROR_TIMEOUT = 5
-  ERROR_THRESHOLD = 1
-  SEMIAN_OPTIONS = {
-    name: :testing,
-    tickets: 1,
-    timeout: 0,
-    error_threshold: ERROR_THRESHOLD,
-    success_threshold: 2,
-    error_timeout: ERROR_TIMEOUT,
-  }
-
-  attr_writer :threads
-  def setup
-    @proxy = Toxiproxy[:semian_test_redis]
-    Semian.destroy(:redis_testing)
-  end
-
-  def test_semian_identifier
-    assert_equal :redis_foo, new_redis(semian: {name: 'foo'}).client.semian_identifier
-    assert_equal :'redis_127.0.0.1:16379/1', new_redis(semian: {name: nil}).client.semian_identifier
-    assert_equal :'redis_example.com:42/1', new_redis(host: 'example.com', port: 42, semian: {name: nil}).client.semian_identifier
-  end
-
-  def test_client_alias
-    redis = connect_to_redis!
-    assert_equal redis.client.semian_resource, redis.semian_resource
-    assert_equal redis.client.semian_identifier, redis.semian_identifier
-  end
-
-  def test_semian_can_be_disabled
-    resource = Redis.new(semian: false).client.semian_resource
-    assert_instance_of Semian::UnprotectedResource, resource
-  end
-
-  def test_semian_resource_in_pipeline
-    redis = connect_to_redis!
-    redis.pipelined do
-      assert_instance_of Semian::ProtectedResource, redis.semian_resource
-    end
-  end
-
-  def test_connection_errors_open_the_circuit
-    client = connect_to_redis!
-
-    @proxy.downstream(:latency, latency: 600).apply do
-      ERROR_THRESHOLD.times do
-        assert_raises ::Redis::TimeoutError do
-          client.get('foo')
-        end
-      end
-
-      assert_raises ::Redis::CircuitOpenError do
-        client.get('foo')
-      end
-    end
-  end
-
-  def test_command_errors_does_not_open_the_circuit
-    client = connect_to_redis!
-    client.hset('my_hash', 'foo', 'bar')
-    (ERROR_THRESHOLD * 2).times do
-      assert_raises Redis::CommandError do
-        client.get('my_hash')
-      end
-    end
-  end
-
-  def test_connect_instrumentation
-    notified = false
-    subscriber = Semian.subscribe do |event, resource, scope, adapter|
-      notified = true
-      assert_equal :success, event
-      assert_equal Semian[:redis_testing], resource
-      assert_equal :connection, scope
-      assert_equal :redis, adapter
-    end
-
-    connect_to_redis!
-
-    assert notified, 'No notifications has been emitted'
-  ensure
-    Semian.unsubscribe(subscriber)
-  end
-
-  def test_resource_acquisition_for_connect
-    connect_to_redis!
-
-    Semian[:redis_testing].acquire do
-      error = assert_raises Redis::ResourceBusyError do
-        connect_to_redis!
-      end
-      assert_equal :redis_testing, error.semian_identifier
-    end
-  end
-
-  def test_redis_connection_errors_are_tagged_with_the_resource_identifier
-    @proxy.downstream(:latency, latency: 600).apply do
-      error = assert_raises ::Redis::TimeoutError do
-        connect_to_redis!
-      end
-      assert_equal :redis_testing, error.semian_identifier
-    end
-  end
-
-  def test_other_redis_errors_are_not_tagged_with_the_resource_identifier
-    client = connect_to_redis!
-    client.set('foo', 'bar')
-    error = assert_raises ::Redis::CommandError do
-      client.hget('foo', 'bar')
-    end
-    refute error.respond_to?(:semian_identifier)
-  end
-
-  def test_resource_timeout_on_connect
-    @proxy.downstream(:latency, latency: 500).apply do
-      background { connect_to_redis! }
-
-      assert_raises Redis::ResourceBusyError do
-        connect_to_redis!
-      end
-    end
-  end
-
-  def test_circuit_breaker_on_connect
-    @proxy.downstream(:latency, latency: 500).apply do
-      background { connect_to_redis! }
-
-      ERROR_THRESHOLD.times do
-        assert_raises Redis::ResourceBusyError do
-          connect_to_redis!
-        end
-      end
-    end
-
-    yield_to_background
-
-    assert_raises Redis::CircuitOpenError do
-      connect_to_redis!
-    end
-
-    Timecop.travel(ERROR_TIMEOUT + 1) do
-      connect_to_redis!
-    end
-  end
-
-  def test_query_instrumentation
-    client = connect_to_redis!
-
-    notified = false
-    subscriber = Semian.subscribe do |event, resource, scope, adapter|
-      notified = true
-      assert_equal :success, event
-      assert_equal Semian[:redis_testing], resource
-      assert_equal :query, scope
-      assert_equal :redis, adapter
-    end
-
-    client.get('foo')
-
-    assert notified, 'No notifications has been emitted'
-  ensure
-    Semian.unsubscribe(subscriber)
-  end
-
-  def test_resource_acquisition_for_query
-    client = connect_to_redis!
-
-    Semian[:redis_testing].acquire do
-      assert_raises Redis::ResourceBusyError do
-        client.get('foo')
-      end
-    end
-  end
-
-  def test_resource_timeout_on_query
-    client = connect_to_redis!
-    client2 = connect_to_redis!
-
-    @proxy.downstream(:latency, latency: 500).apply do
-      background { client2.get('foo') }
-
-      assert_raises Redis::ResourceBusyError do
-        client.get('foo')
-      end
-    end
-  end
-
-  def test_circuit_breaker_on_query
-    client = connect_to_redis!
-    client2 = connect_to_redis!
-
-    client.set('foo', 2)
-
-    @proxy.downstream(:latency, latency: 1000).apply do
-      background { client2.get('foo') }
-
-      ERROR_THRESHOLD.times do
-        assert_raises Redis::ResourceBusyError do
-          client.get('foo')
-        end
-      end
-    end
-
-    yield_to_background
-
-    assert_raises Redis::CircuitOpenError do
-      client.get('foo')
-    end
-
-    Timecop.travel(ERROR_TIMEOUT + 1) do
-      assert_equal '2', client.get('foo')
-    end
-  end
-
-  private
-
-  def new_redis(options = {})
-    semian_options = SEMIAN_OPTIONS.merge(options.delete(:semian) || {})
-    Redis.new({
-      host: '127.0.0.1',
-      port: 16_379,
-      reconnect_attempts: 0,
-      db: 1,
-      timeout: 0.5,
-      semian: semian_options,
-    }.merge(options))
-  end
-
-  def connect_to_redis!(semian_options = {})
-    redis = new_redis(semian: semian_options)
-    redis.client.connect
-    redis
-  end
-end

data/test/resource_test.rb

@@ -1,322 +0,0 @@
-require 'test_helper'
-
-class TestResource < Minitest::Test
-  def setup
-    Semian.destroy(:testing)
-  rescue
-    nil
-  end
-
-  def teardown
-    destroy_resources
-  end
-
-  def test_initialize_invalid_args
-    assert_raises TypeError do
-      create_resource 123, tickets: 2
-    end
-    assert_raises ArgumentError do
-      create_resource :testing, tickets: -1
-    end
-    assert_raises ArgumentError do
-      create_resource :testing, tickets: 1_000_000
-    end
-    assert_raises TypeError do
-      create_resource :testing, tickets: 2, permissions: 'test'
-    end
-  end
-
-  def test_initialize_with_float
-    resource = create_resource :testing, tickets: 1.0
-    assert resource
-    assert_equal 1, resource.tickets
-  end
-
-  def test_max_tickets
-    assert Semian::MAX_TICKETS > 0
-  end
-
-  def test_register
-    create_resource :testing, tickets: 2
-  end
-
-  def test_register_with_no_tickets_raises
-    assert_raises Semian::SyscallError do
-      create_resource :testing, tickets: 0
-    end
-  end
-
-  def test_acquire
-    acquired = false
-    resource = create_resource :testing, tickets: 1
-    resource.acquire { acquired = true }
-    assert acquired
-  end
-
-  def test_acquire_return_val
-    resource = create_resource :testing, tickets: 1
-    val = resource.acquire { 1234 }
-    assert_equal 1234, val
-  end
-
-  def test_acquire_timeout
-    resource = create_resource :testing, tickets: 1, timeout: 0.05
-
-    acquired = false
-    m = Monitor.new
-    cond = m.new_cond
-
-    t = Thread.start do
-      m.synchronize do
-        cond.wait_until { acquired }
-        assert_raises Semian::TimeoutError do
-          resource.acquire { refute true }
-        end
-      end
-    end
-
-    resource.acquire do
-      acquired = true
-      m.synchronize { cond.signal }
-      sleep 0.2
-    end
-
-    t.join
-
-    assert acquired
-  end
-
-  def test_acquire_timeout_override
-    resource = create_resource :testing, tickets: 1, timeout: 0.01
-
-    acquired = false
-    thread_acquired = false
-    m = Monitor.new
-    cond = m.new_cond
-
-    t = Thread.start do
-      m.synchronize do
-        cond.wait_until { acquired }
-        resource.acquire(timeout: 1) { thread_acquired = true }
-      end
-    end
-
-    resource.acquire do
-      acquired = true
-      m.synchronize { cond.signal }
-      sleep 0.2
-    end
-
-    t.join
-
-    assert acquired
-    assert thread_acquired
-  end
-
-  def test_acquire_with_fork
-    resource = create_resource :testing, tickets: 2, timeout: 0.5
-
-    resource.acquire do
-      fork do
-        resource.acquire do
-          assert_raises Semian::TimeoutError do
-            resource.acquire {}
-          end
-        end
-      end
-
-      Process.wait
-    end
-  end
-
-  def test_acquire_releases_on_kill
-    resource = create_resource :testing, tickets: 1, timeout: 0.1
-    acquired = false
-
-    # Ghetto process synchronization
-    file = Tempfile.new('semian')
-    path = file.path
-    file.close!
-
-    pid = fork do
-      resource.acquire do
-        FileUtils.touch(path)
-        sleep 1000
-      end
-    end
-
-    sleep 0.1 until File.exist?(path)
-    assert_raises Semian::TimeoutError do
-      resource.acquire {}
-    end
-
-    Process.kill("KILL", pid)
-    resource.acquire { acquired = true }
-    assert acquired
-
-    Process.wait
-  ensure
-    FileUtils.rm_f(path) if path
-  end
-
-  def test_count
-    resource = create_resource :testing, tickets: 2
-    acquired = false
-
-    resource.acquire do
-      acquired = true
-      assert_equal 1, resource.count
-      assert_equal 2, resource.tickets
-    end
-
-    assert acquired
-  end
-
-  def test_sem_undo
-    resource = create_resource :testing, tickets: 1
-
-    # Ensure we don't hit ERANGE errors caused by lack of SEM_UNDO on semop* calls
-    # by doing an acquire > SEMVMX (32767) times:
-    #
-    # See: http://lxr.free-electrons.com/source/ipc/sem.c?v=3.8#L419
-    (1 << 16).times do # do an acquire 64k times
-      resource.acquire do
-        1
-      end
-    end
-  end
-
-  def test_destroy
-    resource = create_resource :testing, tickets: 1
-    resource.destroy
-    assert_raises Semian::SyscallError do
-      resource.acquire {}
-    end
-  end
-
-  def test_permissions
-    resource = create_resource :testing, permissions: 0600, tickets: 1
-    semid = resource.semid
-    `ipcs -s `.lines.each do |line|
-      if /\s#{semid}\s/.match(line)
-        assert_equal '600', line.split[3]
-      end
-    end
-
-    resource = create_resource :testing, permissions: 0660, tickets: 1
-    semid = resource.semid
-    `ipcs -s `.lines.each do |line|
-      if /\s#{semid}\s/.match(line)
-        assert_equal '660', line.split[3]
-      end
-    end
-  end
-
-  def test_resize_tickets_increase
-    resource = create_resource :testing, tickets: 1
-
-    acquired = false
-    m = Monitor.new
-    cond = m.new_cond
-
-    t = Thread.start do
-      m.synchronize do
-        cond.wait_until { acquired }
-
-        resource = create_resource :testing, tickets: 5
-        assert_equal 4, resource.count
-      end
-    end
-
-    assert_equal 1, resource.count
-
-    resource.acquire do
-      acquired = true
-      m.synchronize { cond.signal }
-      sleep 0.2
-    end
-
-    t.join
-
-    assert_equal 5, resource.count
-  end
-
-  def test_resize_tickets_decrease
-    resource = create_resource :testing, tickets: 5
-
-    acquired = false
-    m = Monitor.new
-    cond = m.new_cond
-
-    t = Thread.start do
-      m.synchronize do
-        cond.wait_until { acquired }
-
-        resource = create_resource :testing, tickets: 1
-        assert_equal 0, resource.count
-      end
-    end
-
-    assert_equal 5, resource.count
-
-    resource.acquire do
-      acquired = true
-      m.synchronize { cond.signal }
-      sleep 0.2
-    end
-
-    t.join
-
-    assert_equal 1, resource.count
-  end
-
-  def test_multiple_register_with_fork
-    f = Tempfile.new('semian_test')
-
-    begin
-      f.flock(File::LOCK_EX)
-
-      children = []
-      5.times do
-        children << fork do
-          acquired = false
-
-          f.flock(File::LOCK_SH)
-          create_resource(:testing, tickets: 5).acquire do |resource|
-            assert resource.count < 5
-            acquired = true
-          end
-          assert acquired
-        end
-      end
-      children.compact!
-
-      f.flock(File::LOCK_UN)
-
-      children.delete(Process.wait) while children.any?
-
-      assert_equal 5, create_resource(:testing, tickets: 0).count
-    ensure
-      f.close!
-    end
-  end
-
-  def create_resource(*args)
-    @resources ||= []
-    resource = Semian::Resource.new(*args)
-    @resources << resource
-    resource
-  end
-
-  def destroy_resources
-    return unless @resources
-    @resources.each do |resource|
-      begin
-        resource.destroy
-      rescue
-        nil
-      end
-    end
-    @resources = []
-  end
-end