circuitbox 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f75524d25326132f1bac120effbfa9b130f95bf1
-  data.tar.gz: ee8a589ff7b55ea95f5e5d119e7c30fe7be4e640
+  metadata.gz: bb9f064a8178b7bfef8be4552f91410d0783acf5
+  data.tar.gz: ca1e8126ff01603f881c351c28c47396a8fa7d97
 SHA512:
-  metadata.gz: 280e82433f43b428b48ee4e5a5a713da46deb723f8df9d886b3e2bf1e7eb922a119c367a706f66d82ee5d731090580773de06030f451ea40784ae544218e1953
-  data.tar.gz: 1b64ba171cfe40c0956ed38f94cc3e37c3e848a051cc987a2944b7578362ab5f51992757208dea50559cb5338d3fcff9c7fa2537ba9df047bfb05f1dabbc4038
+  metadata.gz: f9e3f74178e1cf6200d5dbbf99925ddb1f235ebf3d287e3c82bd0894d1430b69a4ed062bbaf9afb9cacd5b5707c32cf2dcbd10cd78293b5f438f3b738b956837
+  data.tar.gz: fe2a7be07392bd92a0a9e731550f82f1b4e3c6d2ed21759c25d91776e5734d538bb4e7d5bc33da09edd8de5ea2ccdb731e6e8baa36946ea02a7e908415b5c17e

data/.ruby-version

@@ -1 +1 @@
-2.1.5
+2.2.2

data/.travis.yml

@@ -4,5 +4,6 @@ rvm:
   - 2.0.0
   - 2.1
   - 2.2
+  - 2.2.2
 before_install:
    - gem install bundler

data/README.md

@@ -66,6 +66,9 @@ class ExampleServiceClient
 
       # seconds before the circuit times out
       timeout_seconds:  1
+
+      # Logger to use
+      logger: Logger.new(STDOUT)
     })
   end
 end
@@ -298,7 +301,9 @@ c.use Circuitbox::FaradayMiddleware, open_circuit: lambda { |response| response.
 ```
 
 ## CHANGELOG
-### version next
+### v1.1.0
+- ruby 2.2 support [#58](https://github.com/yammer/circuitbox/pull/58)
+- configurable logger [#58](https://github.com/yammer/circuitbox/pull/58)
 
 ### v1.0.3
 - fix timeout issue for default configuration, as default `:Memory` adapter does
@@ -315,7 +320,7 @@ c.use Circuitbox::FaradayMiddleware, open_circuit: lambda { |response| response.
   removing the related railtie.
 
 ### v1.0.0
-- support for cross process circuitbreakers by swapping the circuitbreaker store for a 
+- support for cross process circuitbreakers by swapping the circuitbreaker store for a
   `Moneta` supported key value store.
 - Change `FaradayMiddleware` default behaviour to not open on `4xx` errors but just on `5xx`
   server errors and connection errors

data/circuitbox.gemspec

@@ -3,6 +3,8 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'circuitbox/version'
 
+ruby_2_2_2_plus = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.2.2")
+
 Gem::Specification.new do |spec|
   spec.name          = "circuitbox"
   spec.version       = Circuitbox::VERSION
@@ -20,7 +22,11 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rack"
+  if ruby_2_2_2_plus
+    spec.add_development_dependency "rack"
+  else
+    spec.add_development_dependency "rack", '< 2'
+  end
   spec.add_development_dependency "gimme"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "mocha"
@@ -33,6 +39,10 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "lmdb"
   spec.add_development_dependency "daybreak"
 
-  spec.add_dependency "activesupport"
+  if ruby_2_2_2_plus
+    spec.add_dependency "activesupport"
+  else
+    spec.add_dependency "activesupport", '< 5'
+  end
   spec.add_dependency "moneta"
 end

data/lib/circuitbox/circuit_breaker.rb

@@ -20,6 +20,7 @@ class Circuitbox
     # `timeout_seconds`   - seconds until it will timeout the request
     # `exceptions`        - exceptions other than Timeout::Error that count as failures
     # `time_window`       - interval of time used to calculate error_rate (in seconds) - default is 60s
+    # `logger`            - Logger to use - defaults to Rails.logger if defined, otherwise STDOUT
     #
     def initialize(service, options = {})
       @service = service
@@ -30,7 +31,7 @@ class Circuitbox
       @exceptions = options.fetch(:exceptions) { [] }
       @exceptions = [Timeout::Error] if @exceptions.blank?
 
-      @logger     = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+      @logger     = options.fetch(:logger) { defined?(Rails) ? Rails.logger : Logger.new(STDOUT) }
       @time_class   = options.fetch(:time_class) { Time }
       sanitize_options
     end

data/lib/circuitbox/version.rb

@@ -1,3 +1,3 @@
 class Circuitbox
-VERSION='1.0.3'
+VERSION='1.1.0'
 end

data/test/circuit_breaker_test.rb

@@ -1,26 +1,15 @@
 require 'test_helper'
-require 'ostruct'
 
 class CircuitBreakerTest < Minitest::Test
-  SUCCESSFUL_RESPONSE_STRING = "Success!"
-  RequestFailureError = Timeout::Error
   class ConnectionError < StandardError; end;
-  class SomeOtherError < StandardError; end;
 
   def setup
     Circuitbox::CircuitBreaker.reset
   end
 
-  describe 'initialize' do
-    it 'force sleep_window to equal time_window if it is too short' do
-      circuit = Circuitbox::CircuitBreaker.new(:yammer,
-                                     :sleep_window   =>  1,
-                                     :time_window    => 10
-                                    )
-      assert_equal circuit.option_value(:sleep_window),
-        circuit.option_value(:time_window),
-        'sleep_window has not been corrected properly'
-    end
+  def test_sleep_window_is_forced_to_equal_time_window
+    circuit = Circuitbox::CircuitBreaker.new(:yammer, sleep_window: 1, time_window: 10)
+    assert_equal circuit.option_value(:sleep_window), circuit.option_value(:time_window)
   end
 
   def test_goes_into_half_open_state_on_sleep
@@ -29,35 +18,28 @@ class CircuitBreakerTest < Minitest::Test
     assert circuit.send(:half_open?)
   end
 
-
-  describe 'ratio' do
-    def cb_options
-      {
-        sleep_window:     300,
-        volume_threshold: 5,
-        error_threshold:  33,
-        timeout_seconds:  1
-      }
-    end
-
+  class Ratio < Minitest::Test
     def setup
       Circuitbox::CircuitBreaker.reset
-      @circuit = Circuitbox::CircuitBreaker.new(:yammer, cb_options)
+      @circuit = Circuitbox::CircuitBreaker.new(:yammer, 
+                                                sleep_window: 300,
+                                                volume_threshold: 5,
+                                                error_threshold: 33,
+                                                timeout_seconds: 1)
     end
 
-
-    it 'open the circuit on 100% failure' do
+    def test_open_circuit_on_100_percent_failure
       run_counter = 0
       10.times do
         @circuit.run do
           run_counter += 1
-          raise RequestFailureError
+          raise Timeout::Error
         end
       end
       assert_equal 6, run_counter, 'the circuit did not open after 6 failures (5 failures + 10%)'
     end
 
-    it 'keep circuit closed on 0% failure' do
+    def test_keep_circuit_closed_on_success
       run_counter = 0
       10.times do
         @circuit.run do
@@ -68,12 +50,12 @@ class CircuitBreakerTest < Minitest::Test
       assert_equal 10, run_counter, 'run block was not executed 10 times'
     end
 
-    it 'open the circuit even after 1 success' do
+    def test_open_circuit_on_low_success_rate_below_limit
       run_counter = 0
       5.times do
         @circuit.run do
           run_counter += 1
-          raise RequestFailureError
+          raise Timeout::Error
         end
       end
 
@@ -84,13 +66,13 @@ class CircuitBreakerTest < Minitest::Test
       5.times do
         @circuit.run do
           run_counter += 1
-          raise RequestFailureError
+          raise Timeout::Error
         end
       end
       assert_equal 5, run_counter, 'the circuit did not open after 5 failures (5 failures + 10%)'
     end
 
-    it 'keep circuit closed when failure ratio do not exceed limit' do
+    def test_keep_circuit_closed_on_low_failure_rate_below_failure_limit
       run_counter = 0
       7.times do
         @circuit.run do
@@ -103,14 +85,14 @@ class CircuitBreakerTest < Minitest::Test
       3.times do
         @circuit.run do
           run_counter += 1
-          raise RequestFailureError
+          raise Timeout::Error
         end
       end
       assert_equal 10, run_counter, 'block was not executed 10 times'
       assert @circuit.error_rate < 33, 'error_rate pass over 33%'
     end
 
-    it 'circuit open when failure ratio exceed limit' do
+    def test_open_circuit_on_high_failure_rate_exceeding_failure_limit
       run_counter = 0
       10.times do
         @circuit.run do
@@ -123,79 +105,84 @@ class CircuitBreakerTest < Minitest::Test
       10.times do
         @circuit.run do
           run_counter += 1
-          raise RequestFailureError
+          raise Timeout::Error
         end
       end
       # 5 failure on 15 run is 33%
       assert_equal 15, run_counter, 'block was not executed 10 times'
       assert @circuit.error_rate >= 33, 'error_rate pass over 33%'
     end
-
   end
 
-  describe 'exceptions' do
-    before do
+  class Exceptions < Minitest::Test
+    class SentinalError < StandardError; end
+    
+    def setup
       Circuitbox::CircuitBreaker.reset
-      @circuit = Circuitbox::CircuitBreaker.new(:yammer, exceptions: [SomeOtherError])
+      @circuit = Circuitbox::CircuitBreaker.new(:yammer, exceptions: [SentinalError])
     end
 
-    it 'raises exception when circuit is open' do
+    def test_raises_when_circuit_is_open
       @circuit.stubs(open_flag?: true)
-      -> { @circuit.run! {} }.must_raise Circuitbox::OpenCircuitError
+      assert_raises(Circuitbox::OpenCircuitError) { @circuit.run! {} }
     end
 
-    it 'raises exception when service fails' do
-      err = -> { @circuit.run! { raise SomeOtherError } }.must_raise Circuitbox::ServiceFailureError
-      err.original.must_be_instance_of SomeOtherError
+    def test_raises_on_service_failure
+      assert_raises(Circuitbox::ServiceFailureError) { @circuit.run! { raise SentinalError } }
     end
-  end
 
-  describe 'closing the circuit after sleep' do
-    def cb_options
-      {
-        sleep_window:     1,
-        time_window:      2,
-        volume_threshold: 5,
-        error_threshold:  5,
-        timeout_seconds:  1
-      }
+    def test_sets_original_error_on_service_failure
+      @circuit.run! { raise SentinalError }
+    rescue Circuitbox::ServiceFailureError => service_failure_error
+      assert_instance_of SentinalError, service_failure_error.original
     end
+  end
 
+  class CloseAfterSleep < Minitest::Test
     def setup
-      @circuit = Circuitbox::CircuitBreaker.new(:yammer, cb_options)
+      Circuitbox::CircuitBreaker.reset
+      @circuit = Circuitbox::CircuitBreaker.new(:yammer,
+                                                sleep_window: 1,
+                                                time_window: 2,
+                                                volume_threshold: 5,
+                                                error_threshold: 5,
+                                                timeout_seconds: 1)
     end
 
-    it 'close the circuit after sleeping time' do
-      # lets open the circuit
-      (cb_options[:error_threshold] + 1).times { @circuit.run { raise RequestFailureError } }
+    def test_circuit_closes_after_sleep_time_window
+      open_circuit!
       run_count = 0
       @circuit.run { run_count += 1 }
-      assert_equal 0, run_count, 'circuit is not open'
+      assert_equal 0, run_count, 'circuit has not opened prior'
       # it is + 2 on purpose, because + 1 is flaky here
-      sleep cb_options[:sleep_window] + 2
+      sleep @circuit.option_value(:sleep_window) + 2
 
       @circuit.run { run_count += 1 }
-      assert_equal 1, run_count, 'circuit is not closed'
+      assert_equal 1, run_count, 'circuit did not close after sleep'
+    end
+
+    def open_circuit!
+      (@circuit.option_value(:error_threshold) + 1).times { @circuit.run { raise Timeout::Error } }
     end
   end
 
-  describe "when in half open state" do
-    before do
+  class HalfOpenState < Minitest::Test
+    def setup
       Circuitbox::CircuitBreaker.reset
       @circuit = Circuitbox::CircuitBreaker.new(:yammer)
     end
 
-    it "opens circuit on next failed request" do
+    def test_when_in_half_open_state_circuit_opens_on_failure
       @circuit.stubs(half_open?: true)
       @circuit.expects(:open!)
-      @circuit.run { raise RequestFailureError }
+      @circuit.run { raise Timeout::Error }
     end
 
-    it "closes circuit on successful request" do
+    def test_when_in_half_open_state_circuit_closes_on_success
       @circuit.send(:half_open!)
       @circuit.run { 'success' }
-      assert !@circuit.send(:half_open?)
-      assert !@circuit.send(:open?)
+      refute @circuit.send(:half_open?)
+      refute @circuit.send(:open?)
     end
   end
 
@@ -213,8 +200,8 @@ class CircuitBreakerTest < Minitest::Test
 
   def test_should_return_response_if_it_doesnt_timeout
     circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    response = emulate_circuit_run(circuit, :success, SUCCESSFUL_RESPONSE_STRING)
-    assert_equal SUCCESSFUL_RESPONSE_STRING, response
+    response = emulate_circuit_run(circuit, :success, "success")
+    assert_equal "success", response
   end
 
   def test_timeout_seconds_run_options_overrides_circuit_options
@@ -230,36 +217,37 @@ class CircuitBreakerTest < Minitest::Test
   end
 
   def test_doesnt_catch_out_of_scope_exceptions
-    circuit = Circuitbox::CircuitBreaker.new(:yammer, :exceptions => [ConnectionError, RequestFailureError])
+    sentinal = Class.new(StandardError)
+    circuit = Circuitbox::CircuitBreaker.new(:yammer, :exceptions => [ConnectionError, Timeout::Error])
 
-    assert_raises SomeOtherError do
-      emulate_circuit_run(circuit, :failure, SomeOtherError)
+    assert_raises(sentinal) do
+      emulate_circuit_run(circuit, :failure, sentinal)
     end
   end
 
   def test_records_response_failure
-    circuit = Circuitbox::CircuitBreaker.new(:yammer, :exceptions => [RequestFailureError])
+    circuit = Circuitbox::CircuitBreaker.new(:yammer, :exceptions => [Timeout::Error])
     circuit.expects(:log_event).with(:failure)
-    emulate_circuit_run(circuit, :failure, RequestFailureError)
+    emulate_circuit_run(circuit, :failure, Timeout::Error)
   end
 
   def test_records_response_success
     circuit = Circuitbox::CircuitBreaker.new(:yammer)
     circuit.expects(:log_event).with(:success)
-    emulate_circuit_run(circuit, :success, SUCCESSFUL_RESPONSE_STRING)
+    emulate_circuit_run(circuit, :success, "success")
   end
 
   def test_does_not_send_request_if_circuit_is_open
     circuit = Circuitbox::CircuitBreaker.new(:yammer)
     circuit.stubs(:open? => true)
     circuit.expects(:yield).never
-    response = emulate_circuit_run(circuit, :failure, RequestFailureError)
+    response = emulate_circuit_run(circuit, :failure, Timeout::Error)
     assert_equal nil, response
   end
 
   def test_returns_nil_response_on_failed_request
     circuit = Circuitbox::CircuitBreaker.new(:yammer)
-    response = emulate_circuit_run(circuit, :failure, RequestFailureError)
+    response = emulate_circuit_run(circuit, :failure, Timeout::Error)
     assert_equal nil, response
   end
 
@@ -268,11 +256,11 @@ class CircuitBreakerTest < Minitest::Test
     circuit.stubs(:open? => true)
 
     assert !circuit.send(:open_flag?)
-    emulate_circuit_run(circuit, :failure, RequestFailureError)
+    emulate_circuit_run(circuit, :failure, Timeout::Error)
     assert circuit.send(:open_flag?)
 
     circuit.expects(:open!).never
-    emulate_circuit_run(circuit, :failure, RequestFailureError)
+    emulate_circuit_run(circuit, :failure, Timeout::Error)
   end
 
   def test_open_is_true_if_open_flag
@@ -347,89 +335,80 @@ class CircuitBreakerTest < Minitest::Test
     assert_equal 0, circuit.send(:success_count)
   end
 
-  describe 'notifications' do
-
+  class Notifications < Minitest::Test
     def setup
       Circuitbox::CircuitBreaker.reset
     end
 
-    def circuit
-      Circuitbox::CircuitBreaker.new(:yammer, :notifier_class => @notifier)
-    end
-
-
-    it 'notifies on open circuit' do
-      @notifier = gimme_notifier
-      c = circuit
-      10.times { c.run { raise RequestFailureError }}
-      assert @notifier.notified?, 'no notification sent'
+    def test_notification_on_open
+      notifier = gimme_notifier
+      circuit = Circuitbox::CircuitBreaker.new(:yammer, notifier_class: notifier)
+      10.times { circuit.run { raise Timeout::Error }}
+      assert notifier.notified?, 'no notification sent'
     end
 
-    it 'notifies on close circuit' do
-      @notifier = gimme_notifier
-      c = circuit
-      5.times { c.run { raise RequestFailureError }}
-      clear_notified!
-      10.times { c.run { 'success' }}
-      assert @notifier.notified?, 'no notification sent'
+    def test_notification_on_close
+      notifier = gimme_notifier
+      circuit = Circuitbox::CircuitBreaker.new(:yammer, notifier_class: notifier)      
+      5.times { circuit.run { raise Timeout::Error }}
+      notifier.clear_notified!
+      10.times { circuit.run { 'success' }}
+      assert notifier.notified?, 'no notification sent'
     end
 
-    it 'notifies warning if sleep_window is shorter than time_window' do
-      @notifier = gimme_notifier
+    def test_warning_when_sleep_window_is_shorter_than_time_window
+      notifier = gimme_notifier
       Circuitbox::CircuitBreaker.new(:yammer,
-                                     :notifier_class => @notifier,
-                                     :sleep_window   =>  1,
-                                     :time_window    => 10
-                                    )
-      assert @notifier.notified?, 'no notification sent'
+                                     notifier_class: notifier,
+                                     sleep_window: 1,
+                                     time_window: 10)
+      assert notifier.notified?, 'no notification sent'
     end
 
-    it 'DO NOT notifies warning if sleep_window is longer than time_window' do
-      @notifier = gimme_notifier
+    def test_does_not_warn_on_sleep_window_being_correctly_sized
+      notifier = gimme_notifier
       Circuitbox::CircuitBreaker.new(:yammer,
-                                     :notifier_class => @notifier,
-                                     :sleep_window   => 11,
-                                     :time_window    => 10
-                                    )
-      assert_equal false, @notifier.notified?, 'no notification sent'
+                                     notifier_class: notifier,
+                                     sleep_window: 11,
+                                     time_window: 10)
+      assert_equal false, notifier.notified?, 'no notification sent'
     end
 
-
-    it 'notifies error_rate on error_rate calculation' do
-      @notifier = gimme_notifier(metric: :error_rate, metric_value: 0.0)
-      10.times { circuit.run {'success' }}
-      assert @notifier.notified?, 'no notification sent'
+    def test_notifies_on_success_rate_calculation
+      notifier = gimme_notifier(metric: :error_rate, metric_value: 0.0)
+      circuit = Circuitbox::CircuitBreaker.new(:yammer, notifier_class: notifier)      
+      10.times { circuit.run { "success" } }
+      assert notifier.notified?, "no notification sent"
     end
 
-    it 'notifies failure_count on error_rate calculation' do
-      @notifier = gimme_notifier(metric: :failure_count, metric_value: 1)
-      10.times { circuit.run { raise RequestFailureError  }}
-      assert @notifier.notified?, 'no notification sent'
+    def test_notifies_on_error_rate_calculation
+      notifier = gimme_notifier(metric: :failure_count, metric_value: 1)
+      circuit = Circuitbox::CircuitBreaker.new(:yammer, notifier_class: notifier)
+      10.times { circuit.run { raise Timeout::Error  }}
+      assert notifier.notified?, 'no notification sent'
     end
 
-    it 'notifies success_count on error_rate calculation' do
-      @notifier = gimme_notifier(metric: :success_count, metric_value: 6)
+    def test_success_count_on_error_rate_calculation
+      notifier = gimme_notifier(metric: :success_count, metric_value: 6)
+      circuit = Circuitbox::CircuitBreaker.new(:yammer, notifier_class: notifier)      
       10.times { circuit.run { 'success' }}
-      assert @notifier.notified?, 'no notification sent'
-    end
-
-    def clear_notified!
-      @notified = false
+      assert notifier.notified?, 'no notification sent'
     end
 
     def gimme_notifier(opts={})
-      clear_notified!
-      metric       = opts.fetch(:metric,:error_rate)
+      metric = opts.fetch(:metric,:error_rate)
       metric_value = opts.fetch(:metric_value, 0.0)
-      warning_msg  = opts.fetch(:warning_msg, '')
+      warning_msg = opts.fetch(:warning_msg, '')
       fake_notifier = gimme
-      give(fake_notifier).notify(:open) { @notified=true }
-      give(fake_notifier).notify(:close) { @notified=true }
-      give(fake_notifier).notify_warning(Gimme::Matchers::Anything.new) { @notified = true }
-      give(fake_notifier).metric_gauge(metric, metric_value) { @notified=true }
+      notified = false
+      give(fake_notifier).notify(:open) { notified = true }
+      give(fake_notifier).notify(:close) { notified = true }
+      give(fake_notifier).notify_warning(Gimme::Matchers::Anything.new) { notified = true }
+      give(fake_notifier).metric_gauge(metric, metric_value) { notified = true }
       fake_notifier_class = gimme
       give(fake_notifier_class).new(:yammer,nil) { fake_notifier }
-      give(fake_notifier_class).notified? { @notified }
+      give(fake_notifier_class).notified? { notified }
+      give(fake_notifier_class).clear_notified! { notified = false }
       fake_notifier_class
     end
   end
@@ -443,7 +422,7 @@ class CircuitBreakerTest < Minitest::Test
         response_value
       end
     end
-  rescue RequestFailureError
+  rescue Timeout::Error
     nil
   end
 end

data/test/circuitbox_test.rb

@@ -1,54 +1,45 @@
 require 'test_helper'
 
-class Circuitbox::ExampleStore < ActiveSupport::Cache::MemoryStore; end
+class CircuitboxTest < Minitest::Test
 
-describe Circuitbox do
-  before { Circuitbox.reset }
-  after { Circuitbox.reset }
-
-  describe "Circuitbox.circuit_store" do
-    it "is configurable" do
-      example_store = Circuitbox::ExampleStore.new
-      Circuitbox.circuit_store = example_store
-      assert_equal example_store, Circuitbox[:yammer].circuit_store
-    end
+  def setup
+    Circuitbox.reset
   end
 
-  describe "Circuitbox[:service]" do
-    it "delegates to #circuit" do
-      Circuitbox.expects(:circuit).with(:yammer, {})
-      Circuitbox[:yammer]
-    end
-
-    it "creates a CircuitBreaker instance" do
-      assert Circuitbox[:yammer].is_a? Circuitbox::CircuitBreaker
-    end
+  def test_circuit_store_is_configurable
+    store = Moneta.new(:Memory, expires: true)
+    Circuitbox.circuit_store = store
+    assert_equal store, Circuitbox[:yammer].circuit_store
   end
 
-  describe "#circuit" do
-    it "returns the same circuit every time" do
-      assert_equal Circuitbox.circuit(:yammer).object_id, Circuitbox.circuit(:yammer).object_id
-    end
+  def test_delegates_to_circuit
+    Circuitbox.expects(:circuit).with(:yammer, {})
+    Circuitbox[:yammer]
+  end
 
-    it "sets the circuit options the first time" do
-      circuit_one = Circuitbox.circuit(:yammer, :sleep_window => 1337)
-      circuit_two = Circuitbox.circuit(:yammer, :sleep_window => 2000)
+  def test_creates_a_circuit_breaker
+    assert Circuitbox[:yammer].is_a? Circuitbox::CircuitBreaker
+  end
 
-      assert_equal 1337, circuit_one.option_value(:sleep_window)
-      assert_equal 1337, circuit_two.option_value(:sleep_window)
-    end
+  def test_returns_the_same_circuit_every_time
+    assert_equal Circuitbox.circuit(:yammer), Circuitbox.circuit(:yammer)
   end
 
-  describe "#parameter_to_service_name" do
-    it "parses out a service name from URI" do
-      service = Circuitbox.parameter_to_service_name("http://api.yammer.com/api/v1/messages")
-      assert_equal "api.yammer.com", service
-    end
+  def test_sets_the_circuit_options_the_first_time_only
+    circuit_one = Circuitbox.circuit(:yammer, :sleep_window => 1337)
+    circuit_two = Circuitbox.circuit(:yammer, :sleep_window => 2000)
 
-    it "uses the parameter as the service name if the parameter is not an URI" do
-      service = Circuitbox.parameter_to_service_name(:yammer)
-      assert_equal "yammer", service
-    end
+    assert_equal 1337, circuit_one.option_value(:sleep_window)
+    assert_equal 1337, circuit_two.option_value(:sleep_window)
+  end
+  
+  def test_uses_parsed_uri_host_as_identifier_for_circuit
+    service = Circuitbox.parameter_to_service_name("http://api.yammer.com/api/v1/messages")
+    assert_equal "api.yammer.com", service
   end
 
+  def test_uses_identifier_directly_for_circuit_if_it_is_not_an_uri
+    service = Circuitbox.parameter_to_service_name(:yammer)
+    assert_equal "yammer", service
+  end
 end

data/test/notifier_test.rb

@@ -2,20 +2,20 @@ require 'test_helper'
 require 'circuitbox/notifier'
 require 'active_support/notifications'
 
-describe Circuitbox::Notifier do
-  it "[notify] sends an ActiveSupport::Notification" do
+
+class NotifierTest < Minitest::Test
+  def test_sends_notification_on_notify
     ActiveSupport::Notifications.expects(:instrument).with("circuit_open", circuit: 'yammer:12')
     Circuitbox::Notifier.new(:yammer, 12).notify(:open)
   end
 
-  it "[notify_warning] sends an ActiveSupport::Notification" do
+  def test_sends_warning_notificaiton_notify_warning
     ActiveSupport::Notifications.expects(:instrument).with("circuit_warning", { circuit: 'yammer:12', message: 'hello'})
     Circuitbox::Notifier.new(:yammer, 12).notify_warning('hello')
   end
 
-  it '[gauge] sends an ActiveSupport::Notifier' do
+  def test_sends_metric_as_notification
     ActiveSupport::Notifications.expects(:instrument).with("circuit_gauge", { circuit: 'yammer:12', gauge: 'ratio', value: 12})
     Circuitbox::Notifier.new(:yammer, 12).metric_gauge(:ratio, 12)
-
   end
 end

data/test/service_failure_error_test.rb

@@ -1,30 +1,23 @@
 require 'test_helper'
 
-describe Circuitbox::ServiceFailureError do
+class ServiceFailureErrorTest < Minitest::Test
   class SomeOtherError < StandardError; end;
 
   attr_reader :error
 
-  before do
-    begin
-      raise SomeOtherError, "some other error"
-    rescue => ex
-      @error = ex
-    end
+  def setup
+    raise SomeOtherError, "some other error"
+  rescue => ex
+    @error = ex
   end
 
-  describe '#to_s' do
-    it 'includes message for wrapped exception' do
-      ex = Circuitbox::ServiceFailureError.new('test', error)
-      assert_equal "Circuitbox::ServiceFailureError wrapped: #{error}", ex.to_s
-    end
+  def test_includes_the_message_of_the_wrapped_exception
+    ex = Circuitbox::ServiceFailureError.new('test', error)
+    assert_equal "Circuitbox::ServiceFailureError wrapped: #{error}", ex.to_s
   end
 
-  describe '#backtrace' do
-    it 'keeps the original exception backtrace' do
-      ex = Circuitbox::ServiceFailureError.new('test', error)
-      assert_equal error.backtrace, ex.backtrace
-    end
+  def test_keeps_the_original_backtrace
+    ex = Circuitbox::ServiceFailureError.new('test', error)
+    assert_equal error.backtrace, ex.backtrace
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: circuitbox
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Fahim Ferdous
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-19 00:00:00.000000000 Z
+date: 2016-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -290,7 +290,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: A robust circuit breaker that manages failing external services.