stoplight 3.0.2 → 4.0.0

data/spec/support/data_store/base/names.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'Stoplight::DataStore::Base#names' do
+  it 'is initially empty' do
+    expect(data_store.names).to eql([])
+  end
+
+  it 'contains the name of a light with a failure' do
+    data_store.record_failure(light, failure)
+    expect(data_store.names).to eql([light.name])
+  end
+
+  it 'contains the name of a light with a set state' do
+    data_store.set_state(light, Stoplight::State::UNLOCKED)
+    expect(data_store.names).to eql([light.name])
+  end
+
+  it 'does not duplicate names' do
+    data_store.record_failure(light, failure)
+    data_store.set_state(light, Stoplight::State::UNLOCKED)
+    expect(data_store.names).to eql([light.name])
+  end
+
+  it 'supports names containing colons' do
+    light = Stoplight::Light.new('http://api.example.com/some/action')
+    data_store.record_failure(light, failure)
+    expect(data_store.names).to eql([light.name])
+  end
+end

data/spec/support/data_store/base/record_failures.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'Stoplight::DataStore::Base#record_failure' do
+  it 'returns the number of failures' do
+    expect(data_store.record_failure(light, failure)).to eql(1)
+  end
+
+  context 'when there is an error' do
+    before do
+      data_store.record_failure(light, failure)
+    end
+
+    it 'persists the failure' do
+      expect(data_store.get_failures(light)).to eq([failure])
+    end
+  end
+
+  context 'when there is are several errors' do
+    before do
+      data_store.record_failure(light, failure)
+      data_store.record_failure(light, other)
+    end
+
+    it 'stores more recent failures at the head' do
+      expect(data_store.get_failures(light)).to eq([other, failure])
+    end
+  end
+
+  shared_examples 'with_threshold' do
+    context 'when the number of errors is bigger then threshold' do
+      before do
+        light.with_threshold(1)
+
+        data_store.record_failure(light, failure)
+      end
+
+      it 'limits the number of stored failures' do
+        expect do
+          data_store.record_failure(light, other)
+        end.to change { data_store.get_failures(light) }
+          .from([failure])
+          .to([other])
+      end
+    end
+  end
+
+  it_behaves_like 'with_threshold'
+
+  context 'with window_size' do
+    let(:window_size) { 3600 }
+
+    before do
+      light.with_window_size(window_size)
+    end
+
+    context 'when error is outside of the window' do
+      let(:older_failure) { Stoplight::Failure.new('class', 'message 3', Time.new - window_size - 1) }
+
+      it 'stores failures only withing window length' do
+        data_store.record_failure(light, failure)
+        data_store.record_failure(light, other)
+        data_store.record_failure(light, older_failure)
+
+        expect(data_store.get_failures(light)).to eq([other, failure])
+      end
+    end
+
+    it_behaves_like 'with_threshold'
+  end
+end

data/spec/support/data_store/base/set_state.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'Stoplight::DataStore::Base#set_state' do
+  let(:state) { 'state' }
+
+  it 'returns the state' do
+    expect(data_store.set_state(light, state)).to eql(state)
+  end
+
+  it 'persists the state' do
+    data_store.set_state(light, state)
+
+    expect(data_store.get_state(light)).to eql(state)
+  end
+end

data/spec/support/data_store/base/with_notification_lock.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'Stoplight::DataStore::Base#with_notification_lock' do
+  context 'when notification is already sent' do
+    before do
+      data_store.with_notification_lock(light, Stoplight::Color::GREEN, Stoplight::Color::RED) {}
+    end
+
+    it 'does not yield passed block' do
+      expect do |b|
+        data_store.with_notification_lock(light, Stoplight::Color::GREEN, Stoplight::Color::RED, &b)
+      end.not_to yield_control
+    end
+  end
+
+  context 'when notification is not already sent' do
+    before do
+      data_store.with_notification_lock(light, Stoplight::Color::GREEN, Stoplight::Color::RED) {}
+    end
+
+    it 'yields passed block' do
+      expect do |b|
+        data_store.with_notification_lock(light, Stoplight::Color::RED, Stoplight::Color::GREEN, &b)
+      end.to yield_control
+    end
+  end
+end

data/spec/support/data_store/base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'base/names'
+require_relative 'base/get_failures'
+require_relative 'base/get_all'
+require_relative 'base/record_failures'
+require_relative 'base/clear_failures'
+require_relative 'base/get_state'
+require_relative 'base/set_state'
+require_relative 'base/clear_state'
+require_relative 'base/with_notification_lock'
+
+RSpec.shared_examples 'Stoplight::DataStore::Base' do
+  it 'is a class' do
+    expect(described_class).to be_a(Class)
+  end
+
+  it 'is a subclass of Base' do
+    expect(described_class).to be < Stoplight::DataStore::Base
+  end
+end

data/spec/support/database_cleaner.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'redis'
+require 'database_cleaner/redis'
+
+cleaning_strategy = DatabaseCleaner::Redis::Deletion.new(only: ["#{Stoplight::DataStore::Redis::KEY_PREFIX}*"])
+DatabaseCleaner.strategy = cleaning_strategy
+
+RSpec.shared_context :redis, :redis do
+  let(:redis) { Redis.new(url: ENV.fetch('STOPLIGHT_REDIS_URL', 'redis://127.0.0.1:6379/0')) }
+
+  before(:suite) do
+    DatabaseCleaner[:redis].db = redis
+    DatabaseCleaner.clean_with(:deletion)
+  end
+
+  around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include_context :redis, include_shared: true
+end

data/spec/support/exception_helpers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ExceptionHelpers
+  def suppress(*exception_classes)
+    yield
+  rescue Exception => e # rubocop:disable Lint/RescueException
+    raise unless exception_classes.any? { |cls| e.is_a?(cls) }
+  end
+end

data/spec/support/light/runnable/color.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'Stoplight::Light::Runnable#color' do
+  subject(:light) { Stoplight::Light.new(name) }
+
+  let(:name) { random_string }
+
+  it 'is initially green' do
+    expect(light.color).to eql(Stoplight::Color::GREEN)
+  end
+
+  context 'when its locked green' do
+    before do
+      light.data_store.set_state(light, Stoplight::State::LOCKED_GREEN)
+    end
+
+    it 'is green' do
+      expect(light.color).to eql(Stoplight::Color::GREEN)
+    end
+  end
+
+  context 'when its locked red' do
+    before do
+      light.data_store.set_state(light, Stoplight::State::LOCKED_RED)
+    end
+
+    it 'is red' do
+      expect(light.color).to eql(Stoplight::Color::RED)
+    end
+  end
+
+  context 'when there are many failures' do
+    let(:anther) { Stoplight::Failure.new(error.class.name, error.message, time - 10) }
+
+    before do
+      light.with_threshold(2)
+      light.data_store.record_failure(light, failure)
+    end
+
+    it 'turns red' do
+      expect do
+        light.data_store.record_failure(light, anther)
+      end.to change(light, :color).to be(Stoplight::Color::RED)
+    end
+  end
+
+  context 'when the most recent failure is old' do
+    let(:failure) { Stoplight::Failure.new(error.class.name, error.message, Time.new - light.cool_off_time) }
+    let(:failure2) { Stoplight::Failure.new(error.class.name, error.message, Time.new - light.cool_off_time - 10) }
+
+    before do
+      light.with_threshold(2)
+      light.data_store.record_failure(light, failure2)
+    end
+
+    it 'turns yellow' do
+      expect do
+        light.data_store.record_failure(light, failure)
+      end.to change(light, :color).to be(Stoplight::Color::YELLOW)
+    end
+  end
+
+  context 'when the least recent failure is old' do
+    let(:other) do
+      Stoplight::Failure.new(error.class.name, error.message, Time.new - light.cool_off_time)
+    end
+
+    before do
+      light.with_threshold(2)
+      light.data_store.record_failure(light, other)
+    end
+
+    it 'is red when the least recent failure is old' do
+      expect do
+        light.data_store.record_failure(light, failure)
+      end.to change(light, :color).to be(Stoplight::Color::RED)
+    end
+  end
+end

data/spec/support/light/runnable/run.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'Stoplight::Light::Runnable#run' do
+  let(:code) { -> { code_result } }
+  let(:code_result) { random_string }
+  let(:fallback) { ->(_) { fallback_result } }
+  let(:fallback_result) { random_string }
+  let(:name) { random_string }
+  let(:notifiers) { [notifier] }
+  let(:notifier) { Stoplight::Notifier::IO.new(io) }
+  let(:io) { StringIO.new }
+
+  before { light.with_notifiers(notifiers) }
+
+  shared_examples 'when the light is green' do
+    before { light.data_store.clear_failures(light) }
+
+    it 'runs the code' do
+      expect(run).to eql(code_result)
+    end
+
+    context 'with some failures' do
+      before { light.data_store.record_failure(light, failure) }
+
+      it 'clears the failures' do
+        run
+        expect(light.data_store.get_failures(light).size).to eql(0)
+      end
+    end
+
+    context 'when the code is failing' do
+      let(:code_result) { raise error }
+
+      it 're-raises the error' do
+        expect { run }.to raise_error(error.class)
+      end
+
+      it 'records the failure' do
+        expect(light.data_store.get_failures(light).size).to eql(0)
+        begin
+          run
+        rescue error.class
+          nil
+        end
+        expect(light.data_store.get_failures(light).size).to eql(1)
+      end
+
+      context 'when we did not send notifications yet' do
+        it 'notifies when transitioning to red' do
+          light.threshold.times do
+            expect(io.string).to eql('')
+            begin
+              run
+            rescue error.class
+              nil
+            end
+          end
+          expect(io.string).to_not eql('')
+        end
+      end
+
+      context 'when we already sent notifications' do
+        before do
+          light.data_store.with_notification_lock(light, Stoplight::Color::GREEN, Stoplight::Color::RED) {}
+        end
+
+        it 'does not send new notifications' do
+          light.threshold.times do
+            expect(io.string).to eql('')
+            begin
+              run
+            rescue error.class
+              nil
+            end
+          end
+          expect(io.string).to eql('')
+        end
+      end
+
+      it 'notifies when transitioning to red' do
+        light.threshold.times do
+          expect(io.string).to eql('')
+          begin
+            run
+          rescue error.class
+            nil
+          end
+        end
+        expect(io.string).to_not eql('')
+      end
+
+      context 'with an error handler' do
+        let(:result) do
+          run
+          expect(false).to be(true)
+        rescue error.class
+          expect(true).to be(true)
+        end
+
+        it 'records the failure when the handler does nothing' do
+          light.with_error_handler { |_error, _handler| }
+          expect { result }
+            .to change { light.data_store.get_failures(light).size }
+            .by(1)
+        end
+
+        it 'records the failure when the handler calls handle' do
+          light.with_error_handler { |error, handle| handle.call(error) }
+          expect { result }
+            .to change { light.data_store.get_failures(light).size }
+            .by(1)
+        end
+
+        it 'does not record the failure when the handler raises' do
+          light.with_error_handler { |error, _handle| raise error }
+          expect { result }
+            .to_not change { light.data_store.get_failures(light).size }
+        end
+      end
+
+      context 'with a fallback' do
+        before { light.with_fallback(&fallback) }
+
+        it 'runs the fallback' do
+          expect(run).to eql(fallback_result)
+        end
+
+        it 'passes the error to the fallback' do
+          light.with_fallback do |e|
+            expect(e).to eql(error)
+            fallback_result
+          end
+          expect(run).to eql(fallback_result)
+        end
+      end
+    end
+
+    context 'when the data store is failing' do
+      let(:error_notifier) { ->(_) {} }
+      let(:error) { StandardError.new('something went wrong') }
+
+      before do
+        expect(data_store).to receive(:clear_failures) { raise error }
+
+        light.with_error_notifier(&error_notifier)
+      end
+
+      it 'runs the code' do
+        expect(run).to eql(code_result)
+      end
+
+      it 'notifies about the error' do
+        has_notified = false
+        light.with_error_notifier do |e|
+          has_notified = true
+          expect(e).to eq(error)
+        end
+        run
+        expect(has_notified).to eql(true)
+      end
+    end
+  end
+
+  shared_examples 'when the light is yellow' do
+    let(:failure) { Stoplight::Failure.new(error.class.name, error.message, Time.new - light.cool_off_time) }
+    let(:failure2) { Stoplight::Failure.new(error.class.name, error.message, Time.new - light.cool_off_time - 10) }
+
+    before do
+      light.with_threshold(2)
+      light.data_store.record_failure(light, failure2)
+      light.data_store.record_failure(light, failure)
+    end
+
+    it 'runs the code' do
+      expect(run).to eql(code_result)
+    end
+
+    it 'notifies when transitioning to green' do
+      expect { run }
+        .to change(io, :string)
+        .from(be_empty)
+        .to(/Switching \w+ from red to green/)
+    end
+  end
+
+  shared_examples 'when the light is red' do
+    let(:other) do
+      Stoplight::Failure.new(error.class.name, error.message, Time.new - light.cool_off_time)
+    end
+
+    before do
+      light.with_threshold(2)
+      light.data_store.record_failure(light, other)
+      light.data_store.record_failure(light, failure)
+    end
+
+    it 'raises an error' do
+      expect { run }.to raise_error(Stoplight::Error::RedLight)
+    end
+
+    it 'uses the name as the error message' do
+      expect do
+        run
+      end.to raise_error(Stoplight::Error::RedLight, light.name)
+    end
+
+    context 'with a fallback' do
+      before { light.with_fallback(&fallback) }
+
+      it 'runs the fallback' do
+        expect(run).to eql(fallback_result)
+      end
+
+      it 'does not pass anything to the fallback' do
+        light.with_fallback do |e|
+          expect(e).to eql(nil)
+          fallback_result
+        end
+        expect(run).to eql(fallback_result)
+      end
+    end
+  end
+
+  context 'with code block' do
+    subject(:light) { Stoplight::Light.new(name) }
+
+    def run
+      light.run(&code)
+    end
+
+    it_behaves_like 'when the light is green'
+    it_behaves_like 'when the light is yellow'
+    it_behaves_like 'when the light is red'
+  end
+
+  context 'without code block' do
+    subject(:light) { Stoplight::Light.new(name, &code) }
+
+    def run
+      light.run
+    end
+
+    it_behaves_like 'when the light is green'
+    it_behaves_like 'when the light is yellow'
+    it_behaves_like 'when the light is red'
+  end
+end

data/spec/support/light/runnable.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'runnable/color'
+require_relative 'runnable/run'