stoplight 3.0.0 → 4.0.0

data/spec/stoplight/light_spec.rb

@@ -122,19 +122,9 @@ RSpec.describe Stoplight::Light do
     end
   end
 
-  describe '#with_cool_off_time' do
-    it 'sets the cool off time' do
-      cool_off_time = 1.2
-      light.with_cool_off_time(cool_off_time)
-      expect(light.cool_off_time).to eql(cool_off_time)
-    end
-  end
-
-  describe '#with_data_store' do
-    it 'sets the data store' do
-      data_store = Stoplight::DataStore::Memory.new
-      light.with_data_store(data_store)
-      expect(light.data_store).to eql(data_store)
+  describe '#window_size' do
+    it 'is initially the default' do
+      expect(light.window_size).to eql(Stoplight::Default::WINDOW_SIZE)
     end
   end
 
@@ -162,19 +152,5 @@ RSpec.describe Stoplight::Light do
     end
   end
 
-  describe '#with_notifiers' do
-    it 'sets the notifiers' do
-      notifiers = [Stoplight::Notifier::IO.new(StringIO.new)]
-      light.with_notifiers(notifiers)
-      expect(light.notifiers).to eql(notifiers)
-    end
-  end
-
-  describe '#with_threshold' do
-    it 'sets the threshold' do
-      threshold = 12
-      light.with_threshold(threshold)
-      expect(light.threshold).to eql(threshold)
-    end
-  end
+  it_behaves_like Stoplight::Configurable
 end

data/spec/stoplight/notifier/generic_spec.rb

@@ -2,49 +2,49 @@
 
 require 'spec_helper'
 
-RSpec.shared_examples_for 'a generic notifier' do
-  it 'includes Generic' do
-    expect(described_class).to include(Stoplight::Notifier::Generic)
+RSpec.describe Stoplight::Notifier::Generic do
+  let(:light) { Stoplight::Light.new(name) {} }
+  let(:name) { ('a'..'z').to_a.shuffle.join }
+  let(:from_color) { Stoplight::Color::GREEN }
+  let(:to_color) { Stoplight::Color::RED }
+  let(:error) { nil }
+
+  it 'is a module' do
+    expect(described_class).to be_a(Module)
   end
 
-  describe '#formatter' do
-    it 'is initially the default' do
-      formatter = nil
-      expect(described_class.new(nil, formatter).formatter)
-        .to eql(Stoplight::Default::FORMATTER)
+  describe '#put' do
+    let(:notifier) { notifier_class.new(double.as_null_object) }
+    let(:notifier_class) do
+      Class.new do
+        include Stoplight::Notifier::Generic
+      end
     end
 
-    it 'reads the formatter' do
-      formatter = proc {}
-      expect(described_class.new(nil, formatter).formatter)
-        .to eql(formatter)
+    it 'has to implement the #put method' do
+      expect do
+        notifier.notify(light, from_color, to_color, error)
+      end.to raise_error(NotImplementedError)
     end
   end
 
   describe '#notify' do
-    let(:light) { Stoplight::Light.new(name, &code) }
-    let(:name) { ('a'..'z').to_a.shuffle.join }
-    let(:code) { -> {} }
-    let(:from_color) { Stoplight::Color::GREEN }
-    let(:to_color) { Stoplight::Color::RED }
-    let(:notifier) { described_class.new(double.as_null_object) }
-
-    it 'returns the message' do
-      error = nil
-      expect(notifier.notify(light, from_color, to_color, error))
-        .to eql(notifier.formatter.call(light, from_color, to_color, error))
-    end
-
-    it 'returns the message with an error' do
-      error = ZeroDivisionError.new('divided by 0')
-      expect(notifier.notify(light, from_color, to_color, error))
-        .to eql(notifier.formatter.call(light, from_color, to_color, error))
+    let(:formatted_message) { 'formatted message' }
+    let(:notifier) { notifier_class.new(object) }
+    let(:notifier_class) do
+      Class.new do
+        include Stoplight::Notifier::Generic
+        def put(message)
+          object.put(message)
+        end
+      end
+
+      it 'puts formatted message' do
+        expect(formatter).to receive(:call).with(light, from_color, to_color, error) { formatted_message }
+        expect(object).to receive(:put).with(formatted_message)
+
+        expect(notifier.notify(light, from_color, to_color, error)).to eq(formatted_message)
+      end
     end
   end
 end
-
-RSpec.describe Stoplight::Notifier::Generic do
-  it 'is a module' do
-    expect(described_class).to be_a(Module)
-  end
-end

data/spec/stoplight/notifier/io_spec.rb

@@ -2,6 +2,7 @@
 
 require 'spec_helper'
 require 'stringio'
+require 'stoplight/rspec'
 
 RSpec.describe Stoplight::Notifier::IO do
   it_behaves_like 'a generic notifier'

data/spec/stoplight/notifier/logger_spec.rb

@@ -3,8 +3,11 @@
 require 'spec_helper'
 require 'logger'
 require 'stringio'
+require 'stoplight/rspec'
 
 RSpec.describe Stoplight::Notifier::Logger do
+  it_behaves_like 'a generic notifier'
+
   it 'is a class' do
     expect(described_class).to be_a(Class)
   end

data/spec/stoplight_spec.rb

@@ -9,13 +9,24 @@ RSpec.describe Stoplight do
 end
 
 RSpec.describe 'Stoplight' do
-  subject(:light) { Stoplight(name, &code) }
   let(:name) { ('a'..'z').to_a.shuffle.join }
-  let(:code) { -> {} }
 
-  it 'creates a stoplight' do
-    expect(light).to be_a(Stoplight::Light)
-    expect(light.name).to eql(name)
-    expect(light.code).to eql(code)
+  context 'with code' do
+    subject(:light) { Stoplight(name, &code) }
+    let(:code) { -> {} }
+
+    it 'creates a stoplight' do
+      expect(light).to be_a(Stoplight::Light)
+      expect(light.name).to eql(name)
+      expect(light.code).to eql(code)
+    end
+  end
+
+  context 'without code' do
+    subject(:light) { Stoplight(name) }
+
+    it 'creates a stoplight' do
+      expect(light).to eq(Stoplight::Builder.with(name: name))
+    end
   end
 end

data/spec/support/configurable.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples Stoplight::Configurable do
+  let(:configurable) { described_class.new(configuration) }
+
+  let(:configuration) do
+    Stoplight::Configuration.new(
+      name: name,
+      data_store: Stoplight.default_data_store,
+      notifiers: Stoplight.default_notifiers,
+      error_notifier: Stoplight.default_error_notifier,
+      cool_off_time: Stoplight::Default::COOL_OFF_TIME,
+      threshold: Stoplight::Default::THRESHOLD,
+      window_size: Stoplight::Default::WINDOW_SIZE
+    )
+  end
+
+  shared_examples 'configurable attribute' do |attribute|
+    subject(:with_attribute) do
+      configurable.__send__("with_#{attribute}", __send__(attribute))
+    end
+
+    it "configures #{attribute}" do
+      expect(with_attribute.configuration.__send__(attribute)).to eq(__send__(attribute))
+    end
+  end
+
+  describe '#with_data_store' do
+    let(:data_store) { instance_double(Stoplight::DataStore::Redis) }
+
+    include_examples 'configurable attribute', :data_store
+  end
+
+  describe '#cool_off_time' do
+    let(:cool_off_time) { 1_000 }
+
+    include_examples 'configurable attribute', :cool_off_time
+  end
+
+  describe '#with_threshold' do
+    let(:threshold) { 1_000 }
+
+    include_examples 'configurable attribute', :threshold
+  end
+
+  describe '#with_window_size' do
+    let(:window_size) { 1_000 }
+
+    include_examples 'configurable attribute', :window_size
+  end
+
+  describe '#with_notifiers' do
+    let(:notifiers) { 1_000 }
+
+    include_examples 'configurable attribute', :notifiers
+  end
+
+  describe '#with_error_notifier' do
+    let(:error_notifier) { ->(x) { x } }
+
+    subject(:with_attribute) do
+      configurable.with_error_notifier(&error_notifier)
+    end
+
+    it 'configures error notifier' do
+      expect(with_attribute.configuration.error_notifier).to eq(error_notifier)
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'Stoplight::DataStore::Base#clear_failures' do
+  before do
+    data_store.record_failure(light, failure)
+  end
+
+  it 'returns the failures' do
+    expect(data_store.clear_failures(light)).to contain_exactly(failure)
+  end
+
+  it 'clears the failures' do
+    expect do
+      data_store.clear_failures(light)
+    end.to change { data_store.get_failures(light) }
+      .from([failure]).to(be_empty)
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'Stoplight::DataStore::Base#clear_state' do
+  let(:state) { 'state' }
+
+  it 'returns the state' do
+    data_store.set_state(light, state)
+
+    expect(data_store.clear_state(light)).to eql(state)
+  end
+
+  it 'clears the state' do
+    data_store.set_state(light, state)
+
+    expect do
+      data_store.clear_state(light)
+    end.to change { data_store.get_state(light) }
+      .from(state).to(Stoplight::State::UNLOCKED)
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'Stoplight::DataStore::Base#get_all' do
+  context 'when there are no errors' do
+    it 'returns the failures and the state' do
+      failures, state = data_store.get_all(light)
+
+      expect(failures).to eql([])
+      expect(state).to eql(Stoplight::State::UNLOCKED)
+    end
+  end
+
+  context 'when there are errors' do
+    before do
+      data_store.record_failure(light, failure)
+    end
+
+    it 'returns the failures and the state' do
+      failures, state = data_store.get_all(light)
+
+      expect(failures).to eq([failure])
+      expect(state).to eql(Stoplight::State::UNLOCKED)
+    end
+  end
+
+  context 'when there is a failure outside of the window' do
+    let(:window_size) { 3600 }
+    let(:older_failure) { Stoplight::Failure.new('class', 'message 3', Time.new - window_size - 1) }
+
+    before do
+      light.with_window_size(window_size)
+
+      data_store.record_failure(light, older_failure)
+      data_store.record_failure(light, failure)
+    end
+
+    it 'returns the failures within window and the state' do
+      failures, state = data_store.get_all(light)
+
+      expect(failures).to contain_exactly(failure)
+      expect(state).to eql(Stoplight::State::UNLOCKED)
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'Stoplight::DataStore::Base#get_failures' do
+  it 'is initially empty' do
+    expect(data_store.get_failures(light)).to eql([])
+  end
+
+  it 'handles invalid JSON' do
+    expect { data_store.record_failure(light, failure) }
+      .to change { data_store.get_failures(light) }
+      .from(be_empty)
+      .to(contain_exactly(failure))
+  end
+
+  context 'when there is a failure outside of the window' do
+    let(:window_size) { 3600 }
+    let(:older_failure) { Stoplight::Failure.new('class', 'message 3', Time.new - window_size - 1) }
+
+    before do
+      light.with_window_size(window_size)
+
+      data_store.record_failure(light, failure)
+      data_store.record_failure(light, older_failure)
+    end
+
+    it 'returns failures withing given window' do
+      expect(data_store.get_failures(light)).to contain_exactly(failure)
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples 'Stoplight::DataStore::Base#get_state' do
+  it 'is initially unlocked' do
+    expect(data_store.get_state(light)).to eql(Stoplight::State::UNLOCKED)
+  end
+end

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