stoplight 0.4.1 → 0.5.0

data/spec/stoplight/data_store_spec.rb

@@ -3,74 +3,7 @@
 require 'spec_helper'
 
 describe Stoplight::DataStore do
-  describe '.validate_color!' do
-    subject(:result) { described_class.validate_color!(color) }
-    let(:color) { nil }
-
-    context 'with an invalid color' do
-      it 'raises an error' do
-        expect { result }.to raise_error(Stoplight::Error::InvalidColor)
-      end
-    end
-  end
-
-  describe '.validate_failure!' do
-    subject(:result) { described_class.validate_failure!(failure) }
-    let(:failure) { nil }
-
-    context 'with an invalid failure' do
-      it 'raises an error' do
-        expect { result }.to raise_error(Stoplight::Error::InvalidFailure)
-      end
-    end
-  end
-
-  describe '.validate_state!' do
-    subject(:result) { described_class.validate_state!(state) }
-    let(:state) { nil }
-
-    context 'with an invalid state' do
-      it 'raises an error' do
-        expect { result }.to raise_error(Stoplight::Error::InvalidState)
-      end
-    end
-  end
-
-  describe '.validate_threshold!' do
-    subject(:result) { described_class.validate_threshold!(threshold) }
-    let(:threshold) { nil }
-
-    context 'with an invalid threshold' do
-      it 'raises an error' do
-        expect { result }.to raise_error(Stoplight::Error::InvalidThreshold)
-      end
-    end
-
-    context 'with a negative threshold' do
-      let(:threshold) { -1 }
-
-      it 'raises an error' do
-        expect { result }.to raise_error(Stoplight::Error::InvalidThreshold)
-      end
-    end
-
-    context 'with a zero threshold' do
-      let(:threshold) { 0 }
-
-      it 'raises an error' do
-        expect { result }.to raise_error(Stoplight::Error::InvalidThreshold)
-      end
-    end
-  end
-
-  describe '.validate_timeout!' do
-    subject(:result) { described_class.validate_timeout!(timeout) }
-    let(:timeout) { nil }
-
-    context 'with an invalid timeout' do
-      it 'raises an error' do
-        expect { result }.to raise_error(Stoplight::Error::InvalidTimeout)
-      end
-    end
+  it 'is a module' do
+    expect(described_class).to be_a(Module)
   end
 end

data/spec/stoplight/default_spec.rb

@@ -0,0 +1,86 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::Default do
+  it 'is a module' do
+    expect(described_class).to be_a(Module)
+  end
+
+  describe '::ALLOWED_ERRORS' do
+    it 'is an array' do
+      expect(Stoplight::Default::ALLOWED_ERRORS).to be_an(Array)
+    end
+
+    it 'contains exception classes' do
+      Stoplight::Default::ALLOWED_ERRORS.each do |allowed_error|
+        expect(allowed_error).to be < Exception
+      end
+    end
+
+    it 'is frozen' do
+      expect(Stoplight::Default::ALLOWED_ERRORS).to be_frozen
+    end
+  end
+
+  describe '::DATA_STORE' do
+    it 'is a data store' do
+      expect(Stoplight::Default::DATA_STORE).to be_a(Stoplight::DataStore::Base)
+    end
+  end
+
+  describe '::ERROR_NOTIFIER' do
+    it 'is a proc' do
+      expect(Stoplight::Default::ERROR_NOTIFIER).to be_a(Proc)
+    end
+
+    it 'has an arity of 1' do
+      expect(Stoplight::Default::ERROR_NOTIFIER.arity).to eql(1)
+    end
+  end
+
+  describe '::FALLBACK' do
+    it 'is nil' do
+      expect(Stoplight::Default::FALLBACK).to eql(nil)
+    end
+  end
+
+  describe '::FORMATTER' do
+    it 'is a proc' do
+      expect(Stoplight::Default::FORMATTER).to be_a(Proc)
+    end
+
+    it 'has the same arity as #notify' do
+      notify = Stoplight::Notifier::Base.new.method(:notify)
+      expect(Stoplight::Default::FORMATTER.arity).to eql(notify.arity)
+    end
+  end
+
+  describe '::NOTIFIERS' do
+    it 'is an array' do
+      expect(Stoplight::Default::NOTIFIERS).to be_an(Array)
+    end
+
+    it 'contains notifiers' do
+      Stoplight::Default::NOTIFIERS.each do |notifier|
+        expect(notifier).to be_a(Stoplight::Notifier::Base)
+      end
+    end
+
+    it 'is frozen' do
+      expect(Stoplight::Default::NOTIFIERS).to be_frozen
+    end
+  end
+
+  describe '::THRESHOLD' do
+    it 'is an integer' do
+      expect(Stoplight::Default::THRESHOLD).to be_a(Fixnum)
+    end
+  end
+
+  describe '::TIMEOUT' do
+    it 'is a float' do
+      expect(Stoplight::Default::TIMEOUT).to be_a(Float)
+    end
+  end
+end

data/spec/stoplight/error_spec.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::Error do
+  it 'is a module' do
+    expect(described_class).to be_a(Module)
+  end
+
+  describe '::Base' do
+    it 'is a class' do
+      expect(Stoplight::Error::Base).to be_a(Class)
+    end
+
+    it 'is a subclass of StandardError' do
+      expect(Stoplight::Error::Base).to be < StandardError
+    end
+  end
+
+  describe '::RedLight' do
+    it 'is a class' do
+      expect(Stoplight::Error::RedLight).to be_a(Class)
+    end
+
+    it 'is a subclass of StandardError' do
+      expect(Stoplight::Error::RedLight).to be < Stoplight::Error::Base
+    end
+  end
+end

data/spec/stoplight/failure_spec.rb

@@ -3,80 +3,90 @@
 require 'spec_helper'
 
 describe Stoplight::Failure do
-  subject(:failure) { described_class.new(error_class, error_message, time) }
-  let(:error_class) { SecureRandom.hex }
-  let(:error_message) { SecureRandom.hex }
-  let(:time) { Time.now }
+  let(:error) { ZeroDivisionError.new('divided by 0') }
+  let(:error_class) { error.class.name }
+  let(:error_message) { error.message }
+  let(:time) { Time.new(2001, 2, 3, 4, 5, 6, '+07:08') }
+  let(:json) do
+    JSON.generate(
+      error: { class: error_class, message: error_message },
+      time: time.strftime('%Y-%m-%dT%H:%M:%S.%N%:z'))
+  end
 
-  describe '.create' do
-    subject(:result) { described_class.create(error) }
-    let(:error) { error_class.new(error_message) }
-    let(:error_class) { Class.new(StandardError) }
+  it 'is a class' do
+    expect(described_class).to be_a(Class)
+  end
 
+  describe '.from_error' do
     it 'creates a failure' do
-      expect(result).to be_a(Stoplight::Failure)
-      expect(result.error_class).to eql(error.class.name)
-      expect(result.error_message).to eql(error.message)
-      expect(result.time).to be_within(1).of(Time.now)
+      Timecop.freeze do
+        failure = described_class.from_error(error)
+        expect(failure.error_class).to eql(error_class)
+        expect(failure.error_message).to eql(error_message)
+        expect(failure.time).to eql(Time.new)
+      end
     end
   end
 
   describe '.from_json' do
-    subject(:result) { described_class.from_json(json) }
-    let(:json) { failure.to_json }
-
-    it 'can be round-tripped' do
-      expect(result.error_class).to eq(failure.error_class)
-      expect(result.error_message).to eq(failure.error_message)
-      expect(result.time).to be_within(1).of(failure.time)
+    it 'parses JSON' do
+      failure = described_class.from_json(json)
+      expect(failure.error_class).to eql(error_class)
+      expect(failure.error_message).to eql(error_message)
+      expect(failure.time).to eql(time)
     end
+  end
 
-    context 'with invalid JSON' do
-      let(:json) { nil }
-
-      it 'does not raise an error' do
-        expect { result }.to_not raise_error
-      end
+  describe '#==' do
+    it 'is true when they are equal' do
+      failure = described_class.new(error_class, error_message, time)
+      other = described_class.new(error_class, error_message, time)
+      expect(failure).to eq(other)
+    end
 
-      it 'returns a self-describing invalid failure' do
-        expect(result.error_class).to eq('Stoplight::Error::InvalidFailure')
-        expect(result.error_message).to end_with('nil into String')
-        expect(result.time).to be_within(1).of(Time.now)
-      end
+    it 'is false when they have different error classes' do
+      failure = described_class.new(error_class, error_message, time)
+      other = described_class.new(nil, error_message, time)
+      expect(failure).to_not eq(other)
     end
-  end
 
-  describe '#initialize' do
-    it 'sets the error class' do
-      expect(failure.error_class).to eql(error_class)
+    it 'is false when they have different error messages' do
+      failure = described_class.new(error_class, error_message, time)
+      other = described_class.new(error_class, nil, time)
+      expect(failure).to_not eq(other)
     end
 
-    it 'sets the error message' do
-      expect(failure.error_message).to eql(error_message)
+    it 'is false when they have different times' do
+      failure = described_class.new(error_class, error_message, time)
+      other = described_class.new(error_class, error_message, nil)
+      expect(failure).to_not eq(other)
     end
+  end
 
-    it 'sets the time' do
-      expect(failure.time).to eql(time)
+  describe '#error_class' do
+    it 'reads the error class' do
+      expect(described_class.new(error_class, nil, nil).error_class)
+        .to eql(error_class)
     end
+  end
 
-    context 'without a time' do
-      let(:time) { nil }
+  describe '#error_message' do
+    it 'reads the error message' do
+      expect(described_class.new(nil, error_message, nil).error_message)
+        .to eql(error_message)
+    end
+  end
 
-      it 'uses the default time' do
-        expect(failure.time).to be_within(1).of(Time.now)
-      end
+  describe '#time' do
+    it 'reads the time' do
+      expect(described_class.new(nil, nil, time).time).to eql(time)
     end
   end
 
   describe '#to_json' do
-    subject(:json) { failure.to_json }
-    let(:data) { JSON.load(json) }
-    let(:time) { Time.utc(2001, 2, 3, 4, 5, 6) }
-
-    it 'converts to JSON' do
-      expect(data['error']['class']).to eql(error_class)
-      expect(data['error']['message']).to eql(error_message)
-      expect(data['time']).to eql('2001-02-03T04:05:06Z')
+    it 'generates JSON' do
+      expect(described_class.new(error_class, error_message, time).to_json)
+        .to eql(json)
     end
   end
 end

data/spec/stoplight/light/runnable_spec.rb

@@ -0,0 +1,234 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::Light::Runnable do
+  subject { Stoplight::Light.new(name, &code) }
+
+  let(:code) { -> { code_result } }
+  let(:code_result) { random_string }
+  let(:fallback) { -> _ { fallback_result } }
+  let(:fallback_result) { random_string }
+  let(:name) { random_string }
+
+  let(:failure) do
+    Stoplight::Failure.new(error.class.name, error.message, time)
+  end
+  let(:error) { error_class.new(error_message) }
+  let(:error_class) { Class.new(StandardError) }
+  let(:error_message) { random_string }
+  let(:time) { Time.new }
+
+  def random_number
+    rand(1_000_000)
+  end
+
+  def random_string
+    ('a'..'z').to_a.shuffle.first(8).join
+  end
+
+  describe '#color' do
+    it 'is initially green' do
+      expect(subject.color).to eql(Stoplight::Color::GREEN)
+    end
+
+    it 'is green when locked green' do
+      subject.data_store.set_state(subject, Stoplight::State::LOCKED_GREEN)
+      expect(subject.color).to eql(Stoplight::Color::GREEN)
+    end
+
+    it 'is red when locked red' do
+      subject.data_store.set_state(subject, Stoplight::State::LOCKED_RED)
+      expect(subject.color).to eql(Stoplight::Color::RED)
+    end
+
+    it 'is red when there are many failures' do
+      subject.threshold.times do
+        subject.data_store.record_failure(subject, failure)
+      end
+      expect(subject.color).to eql(Stoplight::Color::RED)
+    end
+
+    it 'is yellow when the most recent failure is old' do
+      (subject.threshold - 1).times do
+        subject.data_store.record_failure(subject, failure)
+      end
+      other = Stoplight::Failure.new(
+        error.class.name, error.message, Time.new - subject.timeout)
+      subject.data_store.record_failure(subject, other)
+      expect(subject.color).to eql(Stoplight::Color::YELLOW)
+    end
+  end
+
+  describe '#run' do
+    let(:notifiers) { [notifier] }
+    let(:notifier) { Stoplight::Notifier::IO.new(io) }
+    let(:io) { StringIO.new }
+
+    before { subject.with_notifiers(notifiers) }
+
+    context 'when the light is green' do
+      before { subject.data_store.clear_failures(subject) }
+
+      it 'runs the code' do
+        expect(subject.run).to eql(code_result)
+      end
+
+      context 'with some failures' do
+        before { subject.data_store.record_failure(subject, failure) }
+
+        it 'clears the failures' do
+          subject.run
+          expect(subject.data_store.get_failures(subject).size).to eql(0)
+        end
+      end
+
+      context 'when the code is failing' do
+        let(:code_result) { fail error }
+
+        it 're-raises the error' do
+          expect { subject.run }.to raise_error(error.class)
+        end
+
+        it 'records the failure' do
+          expect(subject.data_store.get_failures(subject).size).to eql(0)
+          begin
+            subject.run
+          rescue error.class
+            nil
+          end
+          expect(subject.data_store.get_failures(subject).size).to eql(1)
+        end
+
+        it 'notifies when transitioning to red' do
+          subject.threshold.times do
+            expect(io.string).to eql('')
+            begin
+              subject.run
+            rescue error.class
+              nil
+            end
+          end
+          expect(io.string).to_not eql('')
+        end
+
+        context 'when the error is allowed' do
+          let(:allowed_errors) { [error.class] }
+
+          before { subject.with_allowed_errors(allowed_errors) }
+
+          it 'does not record the failure' do
+            expect(subject.data_store.get_failures(subject).size).to eql(0)
+            begin
+              subject.run
+            rescue error.class
+              nil
+            end
+            expect(subject.data_store.get_failures(subject).size).to eql(0)
+          end
+        end
+
+        context 'with a fallback' do
+          before { subject.with_fallback(&fallback) }
+
+          it 'runs the fallback' do
+            expect(subject.run).to eql(fallback_result)
+          end
+
+          it 'passes the error to the fallback' do
+            subject.with_fallback do |e|
+              expect(e).to eql(error)
+              fallback_result
+            end
+            expect(subject.run).to eql(fallback_result)
+          end
+        end
+      end
+
+      context 'when the data store is failing' do
+        let(:data_store) { Object.new }
+        let(:error_notifier) { -> _ {} }
+
+        before do
+          subject
+            .with_data_store(data_store)
+            .with_error_notifier(&error_notifier)
+        end
+
+        it 'runs the code' do
+          expect(subject.run).to eql(code_result)
+        end
+
+        it 'notifies about the error' do
+          has_notified = false
+          subject.with_error_notifier do |e|
+            has_notified = true
+            expect(e).to be_a(NoMethodError)
+          end
+          subject.run
+          expect(has_notified).to eql(true)
+        end
+      end
+    end
+
+    context 'when the light is yellow' do
+      before do
+        (subject.threshold - 1).times do
+          subject.data_store.record_failure(subject, failure)
+        end
+
+        other = Stoplight::Failure.new(
+          error.class.name, error.message, time - subject.timeout)
+        subject.data_store.record_failure(subject, other)
+      end
+
+      it 'runs the code' do
+        expect(subject.run).to eql(code_result)
+      end
+
+      it 'notifies when transitioning to green' do
+        expect(io.string).to eql('')
+        subject.run
+        expect(io.string).to_not eql('')
+      end
+    end
+
+    context 'when the light is red' do
+      before do
+        subject.threshold.times do
+          subject.data_store.record_failure(subject, failure)
+        end
+      end
+
+      it 'raises an error' do
+        expect { subject.run }.to raise_error(Stoplight::Error::RedLight)
+      end
+
+      it 'uses the name as the error message' do
+        e =
+          begin
+            subject.run
+          rescue Stoplight::Error::RedLight => e
+            e
+          end
+        expect(e.message).to eql(subject.name)
+      end
+
+      context 'with a fallback' do
+        before { subject.with_fallback(&fallback) }
+
+        it 'runs the fallback' do
+          expect(subject.run).to eql(fallback_result)
+        end
+
+        it 'does not pass anything to the fallback' do
+          subject.with_fallback do |e|
+            expect(e).to eql(nil)
+            fallback_result
+          end
+          expect(subject.run).to eql(fallback_result)
+        end
+      end
+    end
+  end
+end