circuitbox 1.1.1 → 2.0.0.pre1

data/test/circuitbox_test.rb

@@ -1,45 +0,0 @@
-require 'test_helper'
-
-class CircuitboxTest < Minitest::Test
-
-  def setup
-    Circuitbox.reset
-  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
-
-  def test_delegates_to_circuit
-    Circuitbox.expects(:circuit).with(:yammer, {})
-    Circuitbox[:yammer]
-  end
-
-  def test_creates_a_circuit_breaker
-    assert Circuitbox[:yammer].is_a? Circuitbox::CircuitBreaker
-  end
-
-  def test_returns_the_same_circuit_every_time
-    assert_equal Circuitbox.circuit(:yammer), Circuitbox.circuit(:yammer)
-  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)
-
-    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/excon_middleware_test.rb

@@ -1,131 +0,0 @@
-require 'test_helper'
-require 'circuitbox/excon_middleware'
-
-class SentialException < StandardError; end
-
-class Circuitbox
-  class ExconMiddlewareTest < Minitest::Test
-
-    attr_reader :app
-
-    def setup
-      @app = gimme
-    end
-
-    def test_default_identifier
-      env = { path: "sential" }
-      assert_equal "sential", ExconMiddleware.new(app).identifier.call(env)
-    end
-
-    def test_overwrite_identifier
-      middleware = ExconMiddleware.new(app, identifier: "sential")
-      assert_equal middleware.identifier, "sential"
-    end
-
-    def test_overwrite_default_value_generator_lambda
-      stub_circuitbox
-      env = { path: "path" }
-      give(circuitbox).circuit("path", anything) { circuit }
-      give(circuit).run!(anything) { raise Circuitbox::Error }
-      default_value_generator = lambda { |_, _| :sential }
-      middleware = ExconMiddleware.new(app,
-                                         circuitbox: circuitbox,
-                                         default_value: default_value_generator)
-      assert_equal :sential, middleware.error_call(env)
-    end
-
-    def test_overwrite_default_value_generator_static_value
-      stub_circuitbox
-      env = { path: "path" }
-      give(circuitbox).circuit("path", anything) { circuit }
-      give(circuit).run!(anything) { raise Circuitbox::Error }
-      middleware = ExconMiddleware.new(app, circuitbox: circuitbox, default_value: :sential)
-      assert_equal :sential, middleware.error_call(env)
-    end
-
-    def test_default_exceptions
-      middleware = ExconMiddleware.new(app)
-      assert_includes middleware.exceptions, Excon::Errors::Timeout
-      assert_includes middleware.exceptions, ExconMiddleware::RequestFailed
-    end
-
-    def test_overridde_success_response
-      env = { path: "path", response: { status: 400 } }
-      error_response = lambda { |r| r[:status] >= 500 }
-      give(app).response_call(anything) { Excon::Response.new(status: 400) }
-      mw = ExconMiddleware.new(app, open_circuit: error_response)
-      response = mw.response_call(env)
-      assert_kind_of Excon::Response, response
-      assert_equal response.status, 400
-    end
-
-    def test_default_success_response
-      env = { path: "path", response: { status: 400 } }
-      app = gimme
-      give(app).response_call(anything) { Excon::Response.new(status: 400) }
-      response = nil
-
-      mw = ExconMiddleware.new(app)
-      response = mw.response_call(env)
-
-      assert_kind_of Excon::Response, response
-      assert_equal response.status, 503
-    end
-
-    def test_overwrite_exceptions
-      middleware = ExconMiddleware.new(app, exceptions: [SentialException])
-      assert_includes middleware.exceptions, SentialException
-    end
-
-    def test_pass_circuit_breaker_run_options
-      stub_circuitbox
-      give(circuit).run!(:sential)
-      give(circuitbox).circuit("path", anything) { circuit }
-      env = { path: "path", circuit_breaker_run_options: :sential }
-      middleware = ExconMiddleware.new(app, circuitbox: circuitbox)
-      middleware.request_call(env)
-      verify(circuit, 1.times).run!(:sential)
-    end
-
-    def test_pass_circuit_breaker_options
-      stub_circuitbox
-      env = { path: "path" }
-      expected_circuit_breaker_options = {
-        sential: :sential,
-        exceptions: ExconMiddleware::DEFAULT_EXCEPTIONS
-      }
-      give(circuitbox).circuit("path", expected_circuit_breaker_options) { circuit }
-      options = { circuitbox: circuitbox, circuit_breaker_options: { sential: :sential } }
-      middleware = ExconMiddleware.new(app, options)
-      middleware.request_call(env)
-
-      verify(circuitbox, 1.times).circuit("path", expected_circuit_breaker_options)
-    end
-
-    def test_overwrite_circuitbreaker_default_value
-      stub_circuitbox
-      env = { path: "path", circuit_breaker_default_value: :sential }
-      give(circuitbox).circuit("path", anything) { circuit }
-      give(circuit).run!(anything) { raise Circuitbox::Error }
-      middleware = ExconMiddleware.new(app, circuitbox: circuitbox)
-      assert_equal middleware.error_call(env), :sential
-    end
-
-    def test_return_null_response_for_open_circuit
-      stub_circuitbox
-      env = { path: "path" }
-      give(circuit).run!(anything) { raise Circuitbox::Error }
-      give(circuitbox).circuit("path", anything) { circuit }
-      mw = ExconMiddleware.new(app, circuitbox: circuitbox)
-      response = mw.error_call(env)
-      assert_kind_of Excon::Response, response
-      assert_equal response.status, 503
-    end
-
-    attr_reader :circuitbox, :circuit
-    def stub_circuitbox
-      @circuitbox = gimme
-      @circuit = gimme
-    end
-  end
-end

data/test/faraday_middleware_test.rb

@@ -1,175 +0,0 @@
-require 'test_helper'
-require 'circuitbox/faraday_middleware'
-
-class SentialException < StandardError; end
-
-class Circuitbox
-  class FaradayMiddlewareTest < Minitest::Test
-
-    attr_reader :app
-
-    def setup
-      @app = gimme
-    end
-
-    def test_default_identifier
-      env = { url: "sential" }
-      assert_equal "sential", FaradayMiddleware.new(app).identifier.call(env)
-    end
-
-    def test_overwrite_identifier
-      middleware = FaradayMiddleware.new(app, identifier: "sential")
-      assert_equal middleware.identifier, "sential"
-    end
-
-    def test_overwrite_default_value_generator_lambda
-      stub_circuitbox
-      env = { url: "url" }
-      give(circuitbox).circuit("url", anything) { circuit }
-      give(circuit).run!(anything) { raise Circuitbox::Error }
-      default_value_generator = lambda { |response| :sential }
-      middleware = FaradayMiddleware.new(app,
-                                         circuitbox: circuitbox,
-                                         default_value: default_value_generator)
-      assert_equal :sential, middleware.call(env)
-    end
-
-    def test_default_value_generator_lambda_passed_error
-      stub_circuitbox
-      env = { url: "url" }
-      give(circuitbox).circuit("url", anything) { circuit }
-      give(circuit).run!(anything) { raise Circuitbox::Error.new("error text") }
-      default_value_generator = lambda { |_,error| error.message }
-      middleware = FaradayMiddleware.new(app,
-                                         circuitbox: circuitbox,
-                                         default_value: default_value_generator)
-      assert_equal "error text", middleware.call(env)
-    end
-
-    def test_overwrite_default_value_generator_static_value
-      stub_circuitbox
-      env = { url: "url" }
-      give(circuitbox).circuit("url", anything) { circuit }
-      give(circuit).run!(anything) { raise Circuitbox::Error }
-      middleware = FaradayMiddleware.new(app, circuitbox: circuitbox, default_value: :sential)
-      assert_equal :sential, middleware.call(env)
-    end
-
-    def test_default_exceptions
-      middleware = FaradayMiddleware.new(app)
-      assert_includes middleware.exceptions, Faraday::Error::TimeoutError
-      assert_includes middleware.exceptions, FaradayMiddleware::RequestFailed
-    end
-
-    def test_overridde_success_response
-      env = { url: "url" }
-      app = gimme
-      give(app).call(anything) { Faraday::Response.new(status: 500) }
-      error_response = lambda { |response|  false }
-      response = FaradayMiddleware.new(app, open_circuit: error_response).call(env)
-      assert_kind_of Faraday::Response, response
-      assert_equal response.status, 500
-      assert response.finished?
-      refute response.success?
-    end
-
-    def test_default_success_response
-      env = { url: "url" }
-      app = gimme
-      give(app).call(anything) { Faraday::Response.new(status: 500) }
-      response = FaradayMiddleware.new(app).call(env)
-      assert_kind_of Faraday::Response, response
-      assert_equal response.status, 503
-      assert response.finished?
-      refute response.success?
-    end
-
-    def test_default_open_circuit_does_not_trip_on_400
-      env = { url: "url" }
-      app = gimme
-      give(app).call(anything) { Faraday::Response.new(status: 400) }
-      response = FaradayMiddleware.new(app).call(env)
-      assert_kind_of Faraday::Response, response
-      assert_equal response.status, 400
-      assert response.finished?
-      refute response.success?
-    end
-
-    def test_default_open_circuit_does_trip_on_nil
-      env = { url: "url" }
-      app = gimme
-      give(app).call(anything) { Faraday::Response.new(status: nil) }
-      response = FaradayMiddleware.new(app).call(env)
-      assert_kind_of Faraday::Response, response
-      assert_equal response.status, 503
-      assert response.finished?
-      refute response.success?
-    end
-
-    def test_overwrite_exceptions
-      middleware = FaradayMiddleware.new(app, exceptions: [SentialException])
-      assert_includes middleware.exceptions, SentialException
-    end
-
-    def test_pass_circuit_breaker_run_options
-      stub_circuitbox
-      give(circuit).run!(:sential)
-      give(circuitbox).circuit("url", anything) { circuit }
-      env = { url: "url", circuit_breaker_run_options: :sential }
-      middleware = FaradayMiddleware.new(app, circuitbox: circuitbox)
-      middleware.call(env)
-      verify(circuit, 1.times).run!(:sential)
-    end
-
-    def test_pass_circuit_breaker_options
-      stub_circuitbox
-      env = { url: "url" }
-      expected_circuit_breaker_options = {
-        sential: :sential,
-        exceptions: FaradayMiddleware::DEFAULT_EXCEPTIONS
-      }
-      give(circuitbox).circuit("url", expected_circuit_breaker_options) { circuit }
-      options = { circuitbox: circuitbox, circuit_breaker_options: { sential: :sential } }
-      middleware = FaradayMiddleware.new(app, options)
-      middleware.call(env)
-
-      verify(circuitbox, 1.times).circuit("url", expected_circuit_breaker_options)
-    end
-
-    def test_overwrite_circuitbreaker_default_value
-      stub_circuitbox
-      env = { url: "url", circuit_breaker_default_value: :sential }
-      give(circuitbox).circuit("url", anything) { circuit }
-      give(circuit).run!(anything) { raise Circuitbox::Error }
-      middleware = FaradayMiddleware.new(app, circuitbox: circuitbox)
-      assert_equal middleware.call(env), :sential
-    end
-
-    def test_return_value_closed_circuit
-      stub_circuitbox
-      env = { url: "url" }
-      give(circuit).run!(anything) { :sential }
-      give(circuitbox).circuit("url", anything) { circuit }
-      middleware = FaradayMiddleware.new(app, circuitbox: circuitbox)
-      assert_equal middleware.call(env), :sential
-    end
-
-    def test_return_null_response_for_open_circuit
-      stub_circuitbox
-      env = { url: "url" }
-      give(circuit).run!(anything) { raise Circuitbox::Error }
-      give(circuitbox).circuit("url", anything) { circuit }
-      response = FaradayMiddleware.new(app, circuitbox: circuitbox).call(env)
-      assert_kind_of Faraday::Response, response
-      assert_equal response.status, 503
-      assert response.finished?
-      refute response.success?
-    end
-
-    attr_reader :circuitbox, :circuit
-    def stub_circuitbox
-      @circuitbox = gimme
-      @circuit = gimme
-    end
-  end
-end

data/test/integration/circuitbox_cross_process_open_test.rb

@@ -1,56 +0,0 @@
-require "integration_helper"
-require "tempfile"
-require "typhoeus/adapters/faraday"
-require "pstore"
-
-class Circuitbox
-  class CrossProcessTest < Minitest::Test
-    include IntegrationHelpers
-
-    attr_reader :connection, :failure_url, :dbfile
-
-    @@only_once = false
-    def setup
-      if !@@only_once
-        @dbfile = Tempfile.open("circuitbox_test_cross_process")
-      end
-
-      @connection = Faraday.new do |c|
-        c.use FaradayMiddleware, identifier: "circuitbox_test_cross_process",
-          circuit_breaker_options: { cache: Moneta.new(:PStore, file: dbfile) }
-        c.adapter :typhoeus # support in_parallel
-      end
-      @failure_url = "http://127.0.0.1:4713"
-
-      if !@@only_once
-        pid = fork do
-          Rack::Handler::WEBrick.run(lambda { |env| [500, {}, ["Failure"]] },
-                                     Port: 4713,
-                                     AccessLog: [],
-                                     Logger: WEBrick::Log.new(DEV_NULL))
-        end
-        sleep 0.5
-        Minitest.after_run { Process.kill "KILL", pid }
-      end
-    end
-
-    def teardown
-      Circuitbox.reset
-    end
-
-    def test_circuit_opens_cross_process
-      # Open the circuit via a different process
-      pid = fork do
-        con = Faraday.new do |c|
-          c.use FaradayMiddleware, identifier: "circuitbox_test_cross_process",
-            circuit_breaker_options: { cache: Moneta.new(:PStore, file: dbfile) }
-          c.adapter :typhoeus
-        end
-        open_circuit(con)
-      end
-      Process.wait pid
-      response = connection.get(failure_url)
-      assert response.original_response.nil?, "opening the circuit from a different process should be respected in the main process"
-    end
-  end
-end

data/test/integration/faraday_middleware_test.rb

@@ -1,78 +0,0 @@
-require "integration_helper"
-require "typhoeus/adapters/faraday"
-
-class Circuitbox
-
-  class FaradayMiddlewareTest < Minitest::Test
-    include IntegrationHelpers
-
-    attr_reader :connection, :success_url, :failure_url
-
-    @@only_once = false
-    def setup
-      @connection = Faraday.new do |c|
-        c.use FaradayMiddleware
-        c.adapter :typhoeus # support in_parallel
-      end
-      @success_url = "http://localhost:4711"
-      @failure_url = "http://localhost:4712"
-
-      if !@@only_once
-        FakeServer.create(4711, ['200', {'Content-Type' => 'text/plain'}, ["Success!"]])
-        FakeServer.create(4712, ['500', {'Content-Type' => 'text/plain'}, ["Failure!"]])
-      end
-    end
-
-    def teardown
-      Circuitbox.reset
-    end
-
-    def test_circuit_does_not_open_for_below_threshhold_failed_requests
-      5.times { connection.get(failure_url) }
-      assert_equal connection.get(success_url).status, 200
-    end
-
-    def test_failure_circuit_response
-      failure_response = connection.get(failure_url)
-      assert_equal failure_response.status, 503
-      assert_match failure_response.original_response.body, "Failure!"
-    end
-
-    def test_open_circuit_response
-      open_circuit
-      open_circuit_response = connection.get(failure_url)
-      assert_equal open_circuit_response.status, 503
-      assert_nil open_circuit_response.original_response
-      assert_kind_of Circuitbox::OpenCircuitError, open_circuit_response.original_exception
-    end
-
-    def test_closed_circuit_response
-      result = connection.get(success_url)
-      assert result.success?
-    end
-
-    def test_parallel_requests_closed_circuit_response
-      response_1, response_2 = nil
-      connection.in_parallel do
-        response_1 = connection.get(success_url)
-        response_2 = connection.get(success_url)
-      end
-
-      assert response_1.success?
-      assert response_2.success?
-    end
-
-    def test_parallel_requests_open_circuit_response
-      open_circuit
-      response_1, response_2 = nil
-      connection.in_parallel do
-        response_1 = connection.get(failure_url)
-        response_2 = connection.get(failure_url)
-      end
-
-      assert_equal response_1.status, 503
-      assert_equal response_2.status, 503
-    end
-
-  end
-end