stoplight 3.0.2 → 4.0.0

data/spec/stoplight/data_store/memory_spec.rb

@@ -7,153 +7,16 @@ RSpec.describe Stoplight::DataStore::Memory do
   let(:light) { Stoplight::Light.new(name) {} }
   let(:name) { ('a'..'z').to_a.shuffle.join }
   let(:failure) { Stoplight::Failure.new('class', 'message', Time.new) }
-
-  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
-
-  describe '#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
-
-  describe '#get_all' 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
-
-  describe '#get_failures' do
-    it 'is initially empty' do
-      expect(data_store.get_failures(light)).to eql([])
-    end
-  end
-
-  describe '#record_failure' do
-    it 'returns the number of failures' do
-      expect(data_store.record_failure(light, failure)).to eql(1)
-    end
-
-    it 'persists the failure' do
-      data_store.record_failure(light, failure)
-      expect(data_store.get_failures(light)).to eql([failure])
-    end
-
-    it 'stores more recent failures at the front' do
-      data_store.record_failure(light, failure)
-      other = Stoplight::Failure.new('class', 'message 2', Time.new)
-      data_store.record_failure(light, other)
-      expect(data_store.get_failures(light)).to eql([other, failure])
-    end
-
-    it 'limits the number of stored failures' do
-      light.with_threshold(1)
-      data_store.record_failure(light, failure)
-      other = Stoplight::Failure.new('class', 'message 2', Time.new)
-      data_store.record_failure(light, other)
-      expect(data_store.get_failures(light)).to eql([other])
-    end
-  end
-
-  describe '#clear_failures' do
-    it 'returns the failures' do
-      data_store.record_failure(light, failure)
-      expect(data_store.clear_failures(light)).to eql([failure])
-    end
-
-    it 'clears the failures' do
-      data_store.record_failure(light, failure)
-      data_store.clear_failures(light)
-      expect(data_store.get_failures(light)).to eql([])
-    end
-  end
-
-  describe '#get_state' do
-    it 'is initially unlocked' do
-      expect(data_store.get_state(light)).to eql(Stoplight::State::UNLOCKED)
-    end
-  end
-
-  describe '#set_state' do
-    it 'returns the state' do
-      state = 'state'
-      expect(data_store.set_state(light, state)).to eql(state)
-    end
-
-    it 'persists the state' do
-      state = 'state'
-      data_store.set_state(light, state)
-      expect(data_store.get_state(light)).to eql(state)
-    end
-  end
-
-  describe '#clear_state' do
-    it 'returns the state' do
-      state = 'state'
-      data_store.set_state(light, state)
-      expect(data_store.clear_state(light)).to eql(state)
-    end
-
-    it 'clears the state' do
-      state = 'state'
-      data_store.set_state(light, state)
-      data_store.clear_state(light)
-      expect(data_store.get_state(light)).to eql(Stoplight::State::UNLOCKED)
-    end
-  end
-
-  describe '#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
+  let(:other) { Stoplight::Failure.new('class', 'message 2', Time.new) }
+
+  it_behaves_like 'Stoplight::DataStore::Base'
+  it_behaves_like 'Stoplight::DataStore::Base#names'
+  it_behaves_like 'Stoplight::DataStore::Base#get_failures'
+  it_behaves_like 'Stoplight::DataStore::Base#get_all'
+  it_behaves_like 'Stoplight::DataStore::Base#record_failure'
+  it_behaves_like 'Stoplight::DataStore::Base#clear_failures'
+  it_behaves_like 'Stoplight::DataStore::Base#get_state'
+  it_behaves_like 'Stoplight::DataStore::Base#set_state'
+  it_behaves_like 'Stoplight::DataStore::Base#clear_state'
+  it_behaves_like 'Stoplight::DataStore::Base#with_notification_lock'
 end

data/spec/stoplight/data_store/redis_spec.rb

@@ -1,177 +1,45 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-require 'mock_redis'
 
-RSpec.describe Stoplight::DataStore::Redis do
+RSpec.describe Stoplight::DataStore::Redis, :redis do
   let(:data_store) { described_class.new(redis, redlock: redlock) }
-  let(:redis) { MockRedis.new }
   let(:redlock) { instance_double(Redlock::Client) }
   let(:light) { Stoplight::Light.new(name) {} }
   let(:name) { ('a'..'z').to_a.shuffle.join }
-  let(:failure) { Stoplight::Failure.new('class', 'message', Time.new) }
-
-  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
-
-  describe '#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
-
-  describe '#get_all' 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
-
-  describe '#get_failures' do
-    it 'is initially empty' do
-      expect(data_store.get_failures(light)).to eql([])
-    end
-
-    it 'handles invalid JSON' do
-      expect(redis.keys.size).to eql(0)
-      data_store.record_failure(light, failure)
-      expect(redis.keys.size).to eql(1)
-      redis.lset(redis.keys.first, 0, 'invalid JSON')
-      light.with_error_notifier { |_error| }
-      expect(data_store.get_failures(light).size).to eql(1)
-    end
-  end
-
-  describe '#record_failure' do
-    it 'returns the number of failures' do
-      expect(data_store.record_failure(light, failure)).to eql(1)
-    end
-
-    it 'persists the failure' do
-      data_store.record_failure(light, failure)
-      expect(data_store.get_failures(light)).to eq([failure])
-    end
-
-    it 'stores more recent failures at the head' do
-      data_store.record_failure(light, failure)
-      other = Stoplight::Failure.new('class', 'message 2', Time.new)
-      data_store.record_failure(light, other)
-      expect(data_store.get_failures(light)).to eq([other, failure])
-    end
-
-    it 'limits the number of stored failures' do
-      light.with_threshold(1)
-      data_store.record_failure(light, failure)
-      other = Stoplight::Failure.new('class', 'message 2', Time.new)
-      data_store.record_failure(light, other)
-      expect(data_store.get_failures(light)).to eq([other])
-    end
-  end
-
-  describe '#clear_failures' do
-    it 'returns the failures' do
-      data_store.record_failure(light, failure)
-      expect(data_store.clear_failures(light)).to eq([failure])
-    end
-
-    it 'clears the failures' do
-      data_store.record_failure(light, failure)
-      data_store.clear_failures(light)
-      expect(data_store.get_failures(light)).to eql([])
-    end
-  end
-
-  describe '#get_state' do
-    it 'is initially unlocked' do
-      expect(data_store.get_state(light)).to eql(Stoplight::State::UNLOCKED)
-    end
-  end
-
-  describe '#set_state' do
-    it 'returns the state' do
-      state = 'state'
-      expect(data_store.set_state(light, state)).to eql(state)
-    end
-
-    it 'persists the state' do
-      state = 'state'
-      data_store.set_state(light, state)
-      expect(data_store.get_state(light)).to eql(state)
-    end
-  end
+  let(:failure) { Stoplight::Failure.new('class', 'message', Time.new - 60) }
+  let(:other) { Stoplight::Failure.new('class', 'message 2', Time.new) }
+
+  it_behaves_like 'Stoplight::DataStore::Base'
+  it_behaves_like 'Stoplight::DataStore::Base#names'
+  it_behaves_like 'Stoplight::DataStore::Base#get_all'
+  it_behaves_like 'Stoplight::DataStore::Base#record_failure'
+  it_behaves_like 'Stoplight::DataStore::Base#clear_failures'
+  it_behaves_like 'Stoplight::DataStore::Base#get_state'
+  it_behaves_like 'Stoplight::DataStore::Base#set_state'
+  it_behaves_like 'Stoplight::DataStore::Base#clear_state'
+
+  it_behaves_like 'Stoplight::DataStore::Base#get_failures' do
+    context 'when JSON is invalid' do
+      before do
+        light.with_error_notifier { |_error| }
+      end
 
-  describe '#clear_state' do
-    it 'returns the state' do
-      state = 'state'
-      data_store.set_state(light, state)
-      expect(data_store.clear_state(light)).to eql(state)
-    end
+      it 'handles it without an error' do
+        expect(failure).to receive(:to_json).and_return('invalid JSON')
 
-    it 'clears the state' do
-      state = 'state'
-      data_store.set_state(light, state)
-      data_store.clear_state(light)
-      expect(data_store.get_state(light)).to eql(Stoplight::State::UNLOCKED)
+        expect { data_store.record_failure(light, failure) }
+          .to change { data_store.get_failures(light) }
+          .to([have_attributes(error_class: 'JSON::ParserError')])
+      end
     end
   end
 
-  describe '#with_notification_lock' do
-    let(:lock_key) { "stoplight:notification_lock:#{name}" }
+  it_behaves_like 'Stoplight::DataStore::Base#with_notification_lock' do
+    let(:lock_key) { "stoplight:v4:notification_lock:#{name}" }
 
     before do
       allow(redlock).to receive(:lock).with(lock_key, 2_000).and_yield
     end
-
-    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
 end

data/spec/stoplight/error_spec.rb

@@ -17,6 +17,16 @@ RSpec.describe Stoplight::Error do
     end
   end
 
+  describe '::IncorrectColor' do
+    it 'is a class' do
+      expect(Stoplight::Error::IncorrectColor).to be_a(Class)
+    end
+
+    it 'is a subclass of StandardError' do
+      expect(Stoplight::Error::IncorrectColor).to be < StandardError
+    end
+  end
+
   describe '::RedLight' do
     it 'is a class' do
       expect(Stoplight::Error::RedLight).to be_a(Class)

data/spec/stoplight/light/lockable_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Stoplight::Light::Lockable do
+  subject(:light) { Stoplight::Light.new(name, &code) }
+
+  let(:code) { -> { code_result } }
+  let(:code_result) { random_string }
+  let(:name) { random_string }
+
+  def random_string
+    ('a'..'z').to_a.sample(8).join
+  end
+
+  describe '#lock' do
+    let(:color) { Stoplight::Color::GREEN }
+
+    context 'with correct color' do
+      it 'returns the light' do
+        expect(light.lock(color)).to be_a Stoplight::Light
+      end
+
+      context 'with green color' do
+        let(:color) { Stoplight::Color::GREEN }
+
+        it 'locks green color' do
+          expect(light.data_store).to receive(:set_state).with(light, Stoplight::State::LOCKED_GREEN)
+
+          light.lock(color)
+        end
+      end
+
+      context 'with red color' do
+        let(:color) { Stoplight::Color::RED }
+
+        it 'locks red color' do
+          expect(light.data_store).to receive(:set_state).with(light, Stoplight::State::LOCKED_RED)
+
+          light.lock(color)
+        end
+      end
+    end
+
+    context 'with incorrect color' do
+      let(:color) { 'incorrect-color' }
+
+      it 'raises Error::IncorrectColor error' do
+        expect { light.lock(color) }.to raise_error(Stoplight::Error::IncorrectColor)
+      end
+
+      it 'does not lock color' do
+        expect(light.data_store).to_not receive(:set_state)
+
+        suppress(Stoplight::Error::IncorrectColor) { light.lock(color) }
+      end
+    end
+  end
+
+  describe '#unlock' do
+    it 'returns the light' do
+      expect(light.unlock).to be_a Stoplight::Light
+    end
+
+    context 'with locked green light' do
+      before { light.lock(Stoplight::Color::GREEN) }
+
+      it 'unlocks light' do
+        expect(light.data_store).to receive(:set_state).with(light, Stoplight::State::UNLOCKED)
+
+        light.unlock
+      end
+    end
+
+    context 'with locked red light' do
+      before { light.lock(Stoplight::Color::RED) }
+
+      it 'unlocks light' do
+        expect(light.data_store).to receive(:set_state).with(light, Stoplight::State::UNLOCKED)
+
+        light.unlock
+      end
+    end
+
+    context 'with unlocked light' do
+      it 'unlocks light' do
+        expect(light.data_store).to receive(:set_state).with(light, Stoplight::State::UNLOCKED)
+
+        light.unlock
+      end
+    end
+  end
+end