circuitbox 1.1.1 → 2.0.0.pre4

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

data/test/integration_helper.rb

@@ -1,48 +0,0 @@
-require "test_helper"
-require "faraday"
-require "circuitbox/faraday_middleware"
-require "rack"
-
-class FakeServer
-  def self.instance
-    @@instance ||= FakeServer.new
-    # if the FakeServer is used kill all of them after the tests are done
-    Minitest.after_run { FakeServer.shutdown }
-    @@instance
-  end
-
-  def initialize
-    @servers = []
-  end
-
-  def self.create(port, result)
-    FakeServer.instance.create(port, result)
-  end
-
-  def self.shutdown
-    FakeServer.instance.shutdown
-  end
-
-  def shutdown
-    @servers.map { |server| server.exit }
-    @servers = []
-  end
-
-  def create(port, result)
-    @servers << Thread.new do
-      Rack::Handler::WEBrick.run(Proc.new { |env| result },
-                                 Port: port,
-                                 AccessLog: [],
-                                 Logger: WEBrick::Log.new(DEV_NULL))
-    end
-    sleep 0.5 # wait for the server to spin up
-  end
-end
-
-module IntegrationHelpers
-  def open_circuit(c = connection)
-    volume_threshold = Circuitbox::CircuitBreaker::DEFAULTS[:volume_threshold]
-    (volume_threshold + 1).times { c.get(failure_url) }
-  end
-end
-

data/test/notifier_test.rb

@@ -1,21 +0,0 @@
-require 'test_helper'
-require 'circuitbox/notifier'
-require 'active_support/notifications'
-
-
-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
-
-  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
-
-  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,23 +0,0 @@
-require 'test_helper'
-
-class ServiceFailureErrorTest < Minitest::Test
-  class SomeOtherError < StandardError; end;
-
-  attr_reader :error
-
-  def setup
-    raise SomeOtherError, "some other error"
-  rescue => ex
-    @error = ex
-  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
-
-  def test_keeps_the_original_backtrace
-    ex = Circuitbox::ServiceFailureError.new('test', error)
-    assert_equal error.backtrace, ex.backtrace
-  end
-end

data/test/test_helper.rb

@@ -1,15 +0,0 @@
-require 'minitest/autorun'
-require 'mocha/mini_test'
-require 'timecop'
-require 'gimme'
-require 'circuitbox'
-
-DEV_NULL = (RUBY_PLATFORM =~ /mswin|mingw/ ? "NUL" : "/dev/null")
-
-class Circuitbox
-  class CircuitBreaker
-    def logger
-      @_dev_null_logger ||= Logger.new(DEV_NULL)
-    end
-  end
-end