semian 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 219d1e2e6ab5b6bbc6c90e0e418e47a38a6415cd
-  data.tar.gz: dfe7b83c1f95e26d0df6daa2cde3a914e98d2520
+  metadata.gz: 1da1ae8c9c9376d81347eae49e8755aee743acf1
+  data.tar.gz: dc3b57ca4747df54e05b072c3df52c7e731088a9
 SHA512:
-  metadata.gz: 79f643b811ba718f89a1021c2227b210e4b3045cb5ebc919e6017dcc0334d65efe31a7d30695abf1287f24894794f2c513128e6b07b52553eb0e9cac4cb11e65
-  data.tar.gz: 267d1b19a1c8c6ab7e9786b639a0c326dc9e4669636dfb20a19f36f43386b669029b172ea3f38bf790cc173f7cef9470c1c5b488a694a2c73eb0385ae4ceaa5c
+  metadata.gz: 880796b7330efc3566fbe66a1d1756f99617cc496640ba58d4277e83f401ea65ed5619ed60869ef67049c91d87f620b28f04fdd0015ceb09e5ac4306a33d2a73
+  data.tar.gz: 179a799c1b5d3e07abeb550ee940c527da01781ceceb6c1fd04dd2d42ca5971bde46a886449d4a1739da18944a25323aba593a064526f9ad464a51cdc4f19527

data/.travis.yml

@@ -7,3 +7,6 @@ before_install:
 
 rvm:
   - 2.1.1
+
+services:
+  - redis-server

data/Gemfile

@@ -1,2 +1,6 @@
 source 'https://rubygems.org'
 gemspec
+
+group :debug do
+  gem 'byebug'
+end

data/Rakefile

@@ -29,20 +29,16 @@ else
   task :build do; end
 end
 
-task :populate_proxy do
-  require 'toxiproxy'
-  Toxiproxy.populate(File.expand_path('../test/fixtures/toxiproxy.json', __FILE__))
-end
-
 # ==========================================================
 # Testing
 # ==========================================================
 
 require 'rake/testtask'
 Rake::TestTask.new 'test' do |t|
-  t.pattern = "test/test_*.rb"
+  t.libs = ['lib', 'test']
+  t.pattern = "test/*_test.rb"
 end
-task :test => [:build, :populate_proxy]
+task :test => :build
 
 # ==========================================================
 # Documentation

data/lib/semian.rb

@@ -77,9 +77,20 @@ module Semian
   InternalError = Class.new(BaseError)
   OpenCircuitError = Class.new(BaseError)
 
+  module AdapterError
+    def initialize(semian_identifier, *args)
+      super(*args)
+      @semian_identifier = semian_identifier
+    end
+
+    def to_s
+      "[#{@semian_identifier}] #{super}"
+    end
+  end
+
   attr_accessor :logger
 
-  self.logger = Logger.new(nil)
+  self.logger = Logger.new(STDERR)
 
   # Registers a resource.
   #
@@ -136,11 +147,12 @@ end
 require 'semian/resource'
 require 'semian/circuit_breaker'
 require 'semian/protected_resource'
+require 'semian/unprotected_resource'
 require 'semian/platform'
 if Semian.supported_platform?
   require 'semian/semian'
 else
   Semian::MAX_TICKETS = 0
-  $stderr.puts "Semian is not supported on #{RUBY_PLATFORM} - all operations will no-op"
+  Semian.logger.info("Semian is not supported on #{RUBY_PLATFORM} - all operations will no-op")
 end
 require 'semian/version'

data/lib/semian/adapter.rb

@@ -0,0 +1,56 @@
+module Semian
+  module Adapter
+    def semian_identifier
+      raise NotImplementedError.new("Semian adapters must implement a `semian_identifier` method")
+    end
+
+    def semian_resource
+      @semian_options ||= case semian_options
+      when false
+        UnprotectedResource.new(semian_identifier)
+      when nil
+        Semian.logger.info("Semian is not configured for #{self.class.name}: #{semian_identifier}")
+        UnprotectedResource.new(semian_identifier)
+      else
+        options = semian_options.dup
+        options.delete(:name)
+        ::Semian.retrieve_or_register(semian_identifier, **options)
+      end
+    end
+
+    private
+
+    def acquire_semian_resource(scope:, adapter:, &block)
+      return yield if resource_already_acquired?
+      semian_resource.acquire(scope: scope, adapter: adapter) do
+        mark_resource_as_acquired(&block)
+      end
+    rescue ::Semian::OpenCircuitError => error
+      raise self.class::CircuitOpenError.new(semian_identifier, error)
+    rescue ::Semian::BaseError => error
+      raise self.class::ResourceOccupiedError.new(semian_identifier, error)
+    end
+
+    def semian_options
+      return @semian_options if defined? @semian_options
+      options = raw_semian_options
+      @semian_options = options && options.map { |k, v| [k.to_sym, v] }.to_h
+    end
+
+    def raw_semian_options
+      raise NotImplementedError.new("Semian adapters must implement a `raw_semian_options` method")
+    end
+
+    def resource_already_acquired?
+      @resource_acquired
+    end
+
+    def mark_resource_as_acquired
+      previous = @resource_acquired
+      @resource_acquired = true
+      yield
+    ensure
+      @resource_acquired = previous
+    end
+  end
+end

data/lib/semian/circuit_breaker.rb

@@ -40,7 +40,7 @@ module Semian
     end
 
     def mark_failed(error)
-      increment_recent_errors
+      push_time(@errors, @error_count_threshold, duration: @error_timeout)
 
       if closed?
         open if error_threshold_reached?
@@ -51,14 +51,13 @@ module Semian
 
     def mark_success
       return unless half_open?
-      @success_count += 1
+      @successes += 1
       close if success_threshold_reached?
     end
 
     def reset
-      @success_count = 0
-      @error_count = 0
-      @error_last_at = nil
+      @errors    = []
+      @successes = 0
       close
     end
 
@@ -79,7 +78,7 @@ module Semian
     def close
       log_state_transition(:closed)
       @state = :closed
-      @error_count = 0
+      @errors = []
     end
 
     def open?
@@ -98,35 +97,32 @@ module Semian
     def half_open
       log_state_transition(:half_open)
       @state = :half_open
-      @success_count = 0
-    end
-
-    def increment_recent_errors
-      if error_timeout_expired?
-        @error_count = 0
-      end
-
-      @error_count += 1
-      @error_last_at = Time.now
+      @successes = 0
     end
 
     def success_threshold_reached?
-      @success_count >= @success_count_threshold
+      @successes >= @success_count_threshold
     end
 
     def error_threshold_reached?
-      @error_count >= @error_count_threshold
+      @errors.count == @error_count_threshold
     end
 
     def error_timeout_expired?
-      @error_last_at && (@error_last_at + @error_timeout < Time.now)
+      @errors.last && (@errors.last + @error_timeout < Time.now)
+    end
+
+    def push_time(window, max_size, duration:, time: Time.now)
+      window.shift while window.first && window.first + duration < time
+      window.shift if window.size == max_size
+      window << time
     end
 
     def log_state_transition(new_state)
       return if @state.nil? || new_state == @state
 
       str = "[#{self.class.name}] State transition from #{@state} to #{new_state}."
-      str << " success_count=#{@success_count} error_count=#{@error_count}"
+      str << " success_count=#{@successes} error_count=#{@errors.count}"
       str << " success_count_threshold=#{@success_count_threshold} error_count_threshold=#{@error_count_threshold}"
       str << " error_timeout=#{@error_timeout} error_last_at=\"#{@error_last_at}\""
       Semian.logger.info(str)

data/lib/semian/mysql2.rb

@@ -1,16 +1,10 @@
 require 'semian'
+require 'semian/adapter'
 require 'mysql2'
 
 module Mysql2
   class SemianError < Mysql2::Error
-    def initialize(semian_identifier, *args)
-      super(*args)
-      @semian_identifier = semian_identifier
-    end
-
-    def to_s
-      "[#{@semian_identifier}] #{super}"
-    end
+    include ::Semian::AdapterError
   end
 
   ResourceOccupiedError = Class.new(SemianError)
@@ -19,6 +13,11 @@ end
 
 module Semian
   module Mysql2
+    include Semian::Adapter
+
+    ResourceOccupiedError = ::Mysql2::ResourceOccupiedError
+    CircuitOpenError = ::Mysql2::CircuitOpenError
+
     DEFAULT_HOST = 'localhost'
     DEFAULT_PORT = 3306
 
@@ -33,8 +32,7 @@ module Semian
 
     def semian_identifier
       @semian_identifier ||= begin
-        semian_options = query_options[:semian] || {}
-        unless name = semian_options['name'.freeze] || semian_options[:name]
+        unless name = semian_options && semian_options[:name]
           host = query_options[:host] || DEFAULT_HOST
           port = query_options[:port] || DEFAULT_PORT
           name = "#{host}:#{port}"
@@ -44,32 +42,18 @@ module Semian
     end
 
     def query(*args)
-      semian_resource.acquire(scope: :query) { raw_query(*args) }
-    rescue ::Semian::OpenCircuitError => error
-      raise ::Mysql2::CircuitOpenError.new(semian_identifier, error)
-    rescue ::Semian::BaseError => error
-      raise ::Mysql2::ResourceOccupiedError.new(semian_identifier, error)
+      acquire_semian_resource(adapter: :mysql, scope: :query) { raw_query(*args) }
     end
 
     private
 
     def connect(*args)
-      semian_resource.acquire(scope: :connect) { raw_connect(*args) }
-    rescue ::Semian::OpenCircuitError => error
-      raise ::Mysql2::CircuitOpenError.new(semian_identifier, error)
-    rescue ::Semian::BaseError => error
-      raise ::Mysql2::ResourceOccupiedError.new(semian_identifier, error)
-    end
-
-    def semian_resource
-      @semian_resource ||= ::Semian.retrieve_or_register(semian_identifier, **semian_options)
+      acquire_semian_resource(adapter: :mysql, scope: :connection) { raw_connect(*args) }
     end
 
-    def semian_options
-      options = query_options[:semian] || {}
-      options = options.map { |k, v| [k.to_sym, v] }.to_h
-      options.delete(:name)
-      options
+    def raw_semian_options
+      return query_options[:semian] if query_options.key?(:semian)
+      return query_options['semian'.freeze] if query_options.key?('semian'.freeze)
     end
   end
 end

data/lib/semian/protected_resource.rb

@@ -12,20 +12,20 @@ module Semian
       @circuit_breaker = circuit_breaker
     end
 
-    def acquire(timeout: nil, scope: nil, &block)
+    def acquire(timeout: nil, scope: nil, adapter: nil, &block)
       @circuit_breaker.acquire do
         begin
           @resource.acquire(timeout: timeout) do
-            Semian.notify(:success, self, scope)
+            Semian.notify(:success, self, scope, adapter)
             yield self
           end
         rescue ::Semian::TimeoutError
-          Semian.notify(:occupied, self, scope)
+          Semian.notify(:occupied, self, scope, adapter)
           raise
         end
       end
     rescue ::Semian::OpenCircuitError
-      Semian.notify(:circuit_open, self, scope)
+      Semian.notify(:circuit_open, self, scope, adapter)
       raise
     end
 

data/lib/semian/redis.rb

@@ -0,0 +1,55 @@
+require 'semian'
+require 'semian/adapter'
+require 'redis'
+
+class Redis
+  class SemianError < Redis::BaseConnectionError
+    include ::Semian::AdapterError
+  end
+
+  ResourceOccupiedError = Class.new(SemianError)
+  CircuitOpenError = Class.new(SemianError)
+end
+
+module Semian
+  module Redis
+    include Semian::Adapter
+
+    ResourceOccupiedError = ::Redis::ResourceOccupiedError
+    CircuitOpenError = ::Redis::CircuitOpenError
+
+    # The naked methods are exposed as `raw_query` and `raw_connect` for instrumentation purpose
+    def self.included(base)
+      base.send(:alias_method, :raw_io, :io)
+      base.send(:remove_method, :io)
+
+      base.send(:alias_method, :raw_connect, :connect)
+      base.send(:remove_method, :connect)
+    end
+
+    def semian_identifier
+      @semian_identifier ||= begin
+        name = semian_options && semian_options[:name]
+        name ||= "#{location}/#{db}"
+        :"redis_#{name}"
+      end
+    end
+
+    def io(&block)
+      acquire_semian_resource(adapter: :redis, scope: :query) { raw_io(&block) }
+    end
+
+    def connect
+      acquire_semian_resource(adapter: :redis, scope: :connection) { raw_connect }
+    end
+
+    private
+
+    def raw_semian_options
+      return options[:semian] if options.key?(:semian)
+      return options['semian'.freeze] if options.key?('semian'.freeze)
+    end
+  end
+end
+
+::Redis::Client.include(Semian::Redis)

data/lib/semian/unprotected_resource.rb

@@ -0,0 +1,33 @@
+module Semian
+  # This class acts as a replacement for `ProtectedResource` when
+  # the semian configuration of an `Adatper` is missing or explicitly disabled
+  class UnprotectedResource
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def tickets
+      -1
+    end
+
+    def destroy
+    end
+
+    def acquire(*)
+      yield self
+    end
+
+    def count
+      0
+    end
+
+    def semid
+      0
+    end
+
+    def reset
+    end
+  end
+end

data/lib/semian/version.rb

@@ -1,3 +1,3 @@
 module Semian
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/semian.gemspec

@@ -21,5 +21,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake-compiler', '~> 0.9'
   s.add_development_dependency 'timecop'
   s.add_development_dependency 'mysql2'
+  s.add_development_dependency 'redis'
   s.add_development_dependency 'toxiproxy'
 end

data/test/{test_circuit_breaker.rb → circuit_breaker_test.rb}

@@ -1,6 +1,4 @@
-require 'minitest/autorun'
-require 'semian'
-require 'timecop'
+require 'test_helper'
 
 class TestCircuitBreaker < MiniTest::Unit::TestCase
   SomeError = Class.new(StandardError)
@@ -84,31 +82,60 @@ class TestCircuitBreaker < MiniTest::Unit::TestCase
     assert_circuit_closed
   end
 
+  def test_errors_more_than_duration_apart_doesnt_open_circuit
+    Timecop.travel(Time.now - 6) do
+      trigger_error!
+      assert_circuit_closed
+    end
+
+    trigger_error!
+    assert_circuit_closed
+  end
+
+  def test_sparse_errors_dont_open_circuit
+    resource = Semian.register(:three, tickets: 1, exceptions: [SomeError], error_threshold: 3, error_timeout: 5, success_threshold: 1)
+
+    Timecop.travel(-6) do
+      trigger_error!(resource)
+      assert_circuit_closed(resource)
+    end
+
+    Timecop.travel(-1) do
+      trigger_error!(resource)
+      assert_circuit_closed(resource)
+    end
+
+    trigger_error!(resource)
+    assert_circuit_closed(resource)
+  ensure
+    Semian.destroy(:three)
+  end
+
   private
 
-  def open_circuit!
-    2.times { trigger_error! }
+  def open_circuit!(resource = @resource)
+    2.times { trigger_error!(resource) }
   end
 
-  def half_open_cicuit!
+  def half_open_cicuit!(resource = @resource)
     Timecop.travel(Time.now - 10) do
-      open_circuit!
+      open_circuit!(resource)
     end
   end
 
-  def trigger_error!
-    @resource.with_fallback(42) { raise SomeError }
+  def trigger_error!(resource = @resource)
+    resource.with_fallback(42) { raise SomeError }
   end
 
-  def assert_circuit_closed
+  def assert_circuit_closed(resource = @resource)
     block_called = false
-    @resource.with_fallback(42) { block_called = true }
+    resource.with_fallback(42) { block_called = true }
     assert block_called, 'Expected the circuit to be closed, but it was open'
   end
 
-  def assert_circuit_opened
+  def assert_circuit_opened(resource = @resource)
     block_called = false
-    @resource.with_fallback(42) { block_called = true }
+    resource.with_fallback(42) { block_called = true }
     refute block_called, 'Expected the circuit to be open, but it was closed'
   end
 end

data/test/helpers/background_helper.rb

@@ -0,0 +1,25 @@
+module BackgroundHelper
+  attr_writer :threads
+
+  def teardown
+    threads.each { |t| t.kill }
+    self.threads = []
+  end
+
+  private
+
+  def background(&block)
+    thread = Thread.new(&block)
+    threads << thread
+    thread.join(0.1)
+    thread
+  end
+
+  def threads
+    @threads ||= []
+  end
+
+  def yield_to_background
+    threads.each(&:join)
+  end
+end

data/test/{test_instrumentation.rb → instrumentation_test.rb}

@@ -1,5 +1,4 @@
-require 'minitest/autorun'
-require 'semian'
+require 'test_helper'
 
 class TestInstrumentation < MiniTest::Unit::TestCase
   def setup

data/test/{test_mysql2.rb → mysql2_test.rb}

@@ -1,7 +1,4 @@
-require 'minitest/autorun'
-require 'semian/mysql2'
-require 'toxiproxy'
-require 'timecop'
+require 'test_helper'
 
 class TestMysql2 < MiniTest::Unit::TestCase
   ERROR_TIMEOUT = 5
@@ -15,17 +12,11 @@ class TestMysql2 < MiniTest::Unit::TestCase
     error_timeout: ERROR_TIMEOUT,
   }
 
-  attr_writer :threads
   def setup
     @proxy = Toxiproxy[:semian_test_mysql]
     Semian.destroy(:mysql_testing)
   end
 
-  def teardown
-    threads.each { |t| t.kill }
-    self.threads = []
-  end
-
   def test_semian_identifier
     assert_equal :mysql_foo, FakeMysql.new(semian: {name: 'foo'}).semian_identifier
     assert_equal :'mysql_localhost:3306', FakeMysql.new.semian_identifier
@@ -33,18 +24,24 @@ class TestMysql2 < MiniTest::Unit::TestCase
     assert_equal :'mysql_example.com:42', FakeMysql.new(host: 'example.com', port: 42).semian_identifier
   end
 
+  def test_semian_can_be_disabled
+    resource = Mysql2::Client.new(semian: false).semian_resource
+    assert_instance_of Semian::UnprotectedResource, resource
+  end
+
   def test_connect_instrumentation
     notified = false
-    subscriber = Semian.subscribe do |event, resource, scope|
+    subscriber = Semian.subscribe do |event, resource, scope, adapter|
       notified = true
       assert_equal :success, event
       assert_equal Semian[:mysql_testing], resource
-      assert_equal :connect, scope
+      assert_equal :connection, scope
+      assert_equal :mysql, adapter
     end
 
     connect_to_mysql!
 
-    assert notified, 'No notification have been emitted'
+    assert notified, 'No notifications has been emitted'
   ensure
     Semian.unsubscribe(subscriber)
   end
@@ -95,16 +92,17 @@ class TestMysql2 < MiniTest::Unit::TestCase
     client = connect_to_mysql!
 
     notified = false
-    subscriber = Semian.subscribe do |event, resource, scope|
+    subscriber = Semian.subscribe do |event, resource, scope, adapter|
       notified = true
       assert_equal :success, event
       assert_equal Semian[:mysql_testing], resource
       assert_equal :query, scope
+      assert_equal :mysql, adapter
     end
 
     client.query('SELECT 1 + 1;')
 
-    assert notified, 'No notification have been emitted'
+    assert notified, 'No notifications has been emitted'
   ensure
     Semian.unsubscribe(subscriber)
   end
@@ -157,22 +155,12 @@ class TestMysql2 < MiniTest::Unit::TestCase
     end
   end
 
-  private
-
-  def background(&block)
-    thread = Thread.new(&block)
-    threads << thread
-    thread.join(0.1)
-    thread
-  end
-
-  def threads
-    @threads ||= []
+  def test_unconfigured
+    client = Mysql2::Client.new(host: '127.0.0.1', port: '13306')
+    assert_equal 2, client.query('SELECT 1 + 1 as sum;').to_a.first['sum']
   end
 
-  def yield_to_background
-    threads.each(&:join)
-  end
+  private
 
   def connect_to_mysql!(semian_options = {})
     Mysql2::Client.new(host: '127.0.0.1', port: '13306', semian: SEMIAN_OPTIONS.merge(semian_options))

data/test/redis_test.rb

@@ -0,0 +1,167 @@
+require 'test_helper'
+
+class TestRedis < MiniTest::Unit::TestCase
+  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, Redis.new(semian: {name: 'foo'}).client.semian_identifier
+    assert_equal :'redis_127.0.0.1:6379/0', Redis.new.client.semian_identifier
+    assert_equal :'redis_example.com:42/0', Redis.new(host: 'example.com', port: 42).client.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_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
+    client = connect_to_redis!
+
+    Semian[:redis_testing].acquire do
+      assert_raises Redis::ResourceOccupiedError do
+        connect_to_redis!
+      end
+    end
+  end
+
+  def test_resource_timeout_on_connect
+    @proxy.downstream(:latency, latency: 500).apply do
+      background { connect_to_redis! }
+
+      assert_raises Redis::ResourceOccupiedError 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::ResourceOccupiedError 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::ResourceOccupiedError 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::ResourceOccupiedError 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::ResourceOccupiedError 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 connect_to_redis!(semian_options = {})
+    redis = Redis.new(host: '127.0.0.1', port: 16379, reconnect_attempts: 0, db: 1, semian: SEMIAN_OPTIONS.merge(semian_options))
+    redis.client.connect
+    redis
+  end
+end

data/test/{test_resource.rb → resource_test.rb}

@@ -1,7 +1,4 @@
-require 'minitest/autorun'
-require 'semian'
-require 'tempfile'
-require 'fileutils'
+require 'test_helper'
 
 class TestResource < MiniTest::Unit::TestCase
   def setup

data/test/test_helper.rb

@@ -0,0 +1,28 @@
+require 'minitest/autorun'
+require 'semian'
+require 'semian/mysql2'
+require 'semian/redis'
+require 'toxiproxy'
+require 'timecop'
+require 'tempfile'
+require 'fileutils'
+
+require 'helpers/background_helper'
+
+Semian.logger = Logger.new(nil)
+Toxiproxy.populate([
+  {
+    name: 'semian_test_mysql',
+    upstream: 'localhost:3306',
+    listen: 'localhost:13306',
+  },
+  {
+    name: 'semian_test_redis',
+    upstream: 'localhost:6379',
+    listen: 'localhost:16379',
+  },
+])
+
+class MiniTest::Unit::TestCase
+  include BackgroundHelper
+end

data/test/unprotected_resource_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class UnprotectedResourceTest < MiniTest::Unit::TestCase
+  def setup
+    @resource = Semian::UnprotectedResource.new(:foo)
+  end
+
+  def test_resource_name
+    assert_equal :foo, @resource.name
+  end
+
+  def test_resource_tickets
+    assert_equal -1, @resource.tickets
+  end
+
+  def test_resource_count
+    assert_equal 0, @resource.count
+  end
+
+  def test_resource_semid
+    assert_equal 0, @resource.semid
+  end
+
+  def test_resource_reset
+    @resource.reset
+  end
+
+  def test_resource_destroy
+    @resource.destroy
+  end
+
+  def test_resource_acquire
+    acquired = false
+    @resource.acquire do
+      acquired = true
+    end
+    assert acquired
+  end
+
+  def test_resource_acquire_with_timeout
+    acquired = false
+    @resource.acquire(timeout: 2) do
+      acquired = true
+    end
+    assert acquired
+  end
+
+end

data/test/{test_unsupported.rb → unsupported_test.rb}

@@ -1,5 +1,4 @@
-require 'minitest/autorun'
-require 'semian'
+require 'test_helper'
 
 class TestSemian < MiniTest::Unit::TestCase
   def setup

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: semian
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Scott Francis
@@ -31,7 +31,7 @@ cert_chain:
   fl3hbtVFTqbOlwL9vy1fudXcolIE/ZTcxQ+er07ZFZdKCXayR9PPs64heamfn0fp
   TConQSX2BnZdhIEYW+cKzEC/bLc=
   -----END CERTIFICATE-----
-date: 2015-02-13 00:00:00.000000000 Z
+date: 2015-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -75,6 +75,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: toxiproxy
   requirement: !ruby/object:Gem::Requirement
@@ -107,21 +121,27 @@ files:
 - ext/semian/extconf.rb
 - ext/semian/semian.c
 - lib/semian.rb
+- lib/semian/adapter.rb
 - lib/semian/circuit_breaker.rb
 - lib/semian/instrumentable.rb
 - lib/semian/mysql2.rb
 - lib/semian/platform.rb
 - lib/semian/protected_resource.rb
+- lib/semian/redis.rb
 - lib/semian/resource.rb
+- lib/semian/unprotected_resource.rb
 - lib/semian/version.rb
 - scripts/install_toxiproxy.sh
 - semian.gemspec
-- test/fixtures/toxiproxy.json
-- test/test_circuit_breaker.rb
-- test/test_instrumentation.rb
-- test/test_mysql2.rb
-- test/test_resource.rb
-- test/test_unsupported.rb
+- test/circuit_breaker_test.rb
+- test/helpers/background_helper.rb
+- test/instrumentation_test.rb
+- test/mysql2_test.rb
+- test/redis_test.rb
+- test/resource_test.rb
+- test/test_helper.rb
+- test/unprotected_resource_test.rb
+- test/unsupported_test.rb
 homepage: https://github.com/csfrancis/semian
 licenses:
 - MIT

data/test/fixtures/toxiproxy.json

@@ -1,7 +0,0 @@
-[
-  {
-    "name": "semian_test_mysql",
-    "upstream": "localhost:3306",
-    "listen": "localhost:13306"
-  }
-]