stoplight 0.1.0

data/spec/stoplight/data_store/redis_spec.rb

@@ -0,0 +1,190 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'fakeredis'
+
+describe Stoplight::DataStore::Redis do
+  let(:error) { error_class.new }
+  let(:error_class) { Class.new(StandardError) }
+  let(:name) { SecureRandom.hex }
+  let(:state) { Stoplight::DataStore::STATES.to_a.sample }
+  let(:threshold) { rand(10) }
+
+  subject(:data_store) { described_class.new }
+
+  describe '#attempts' do
+    subject(:result) { data_store.attempts(name) }
+
+    it 'returns 0' do
+      expect(result).to eql(0)
+    end
+
+    context 'with an attempt' do
+      before { data_store.record_attempt(name) }
+
+      it 'returns 1' do
+        expect(result).to eql(1)
+      end
+    end
+  end
+
+  describe '#clear_attempts' do
+    subject(:result) { data_store.clear_attempts(name) }
+
+    it 'returns 0' do
+      expect(result).to eql(0)
+    end
+
+    context 'with an attempt' do
+      before { data_store.record_attempt(name) }
+
+      it 'returns 1' do
+        expect(result).to eql(1)
+      end
+
+      it 'clears the attempts' do
+        result
+        expect(data_store.attempts(name)).to eql(0)
+      end
+    end
+  end
+
+  describe '#clear_failures' do
+    subject(:result) { data_store.clear_failures(name) }
+
+    it 'returns 0' do
+      expect(result).to eql(0)
+    end
+
+    context 'with a failure' do
+      before { data_store.record_failure(name, error) }
+
+      it 'returns 1' do
+        expect(result).to eql(1)
+      end
+
+      it 'clears the failures' do
+        result
+        expect(data_store.failures(name)).to be_empty
+      end
+    end
+  end
+
+  describe '#failures' do
+    subject(:result) { data_store.failures(name) }
+
+    it 'returns an empty array' do
+      expect(result).to be_an(Array)
+      expect(result).to be_empty
+    end
+
+    context 'with a failure' do
+      before { data_store.record_failure(name, error) }
+
+      it 'returns a non-empty array' do
+        expect(result).to be_an(Array)
+        expect(result).to_not be_empty
+      end
+    end
+  end
+
+  describe '#names' do
+    subject(:result) { data_store.names }
+
+    it 'returns an array' do
+      expect(result).to be_an(Array)
+    end
+
+    context 'with a name' do
+      before { data_store.set_threshold(name, threshold) }
+
+      it 'includes the name' do
+        expect(result).to include(name)
+      end
+    end
+  end
+
+  describe '#record_attempt' do
+    subject(:result) { data_store.record_attempt(name) }
+
+    it 'returns 1' do
+      expect(result).to eql(1)
+    end
+
+    it 'records the attempt' do
+      result
+      expect(data_store.attempts(name)).to eql(1)
+    end
+  end
+
+  describe '#record_failure' do
+    subject(:result) { data_store.record_failure(name, error) }
+
+    it 'returns 1' do
+      expect(result).to eql(1)
+    end
+
+    it 'records the failure' do
+      result
+      expect(data_store.failures(name)).to_not be_empty
+    end
+  end
+
+  describe '#set_state' do
+    subject(:result) { data_store.set_state(name, state) }
+
+    it 'returns the state' do
+      expect(result).to eql(state)
+    end
+
+    it 'sets the state' do
+      result
+      expect(data_store.state(name)).to eql(state)
+    end
+  end
+
+  describe '#set_threshold' do
+    subject(:result) { data_store.set_threshold(name, threshold) }
+
+    it 'returns the threshold' do
+      expect(result).to eql(threshold)
+    end
+
+    it 'sets the threshold' do
+      result
+      expect(data_store.threshold(name)).to eql(threshold)
+    end
+  end
+
+  describe '#state' do
+    subject(:result) { data_store.state(name) }
+
+    it 'returns the default state' do
+      expect(result).to eql(Stoplight::DataStore::STATE_UNLOCKED)
+    end
+
+    context 'with a state' do
+      before { data_store.set_state(name, state) }
+
+      it 'returns the state' do
+        expect(result).to eql(state)
+      end
+    end
+  end
+
+  describe '#threshold' do
+    subject(:result) { data_store.threshold(name) }
+
+    it 'returns nil' do
+      expect(result).to be(nil)
+    end
+
+    context 'with a threshold' do
+      before { data_store.set_threshold(name, threshold) }
+
+      it 'returns the threshold' do
+        expect(result).to eql(threshold)
+      end
+    end
+  end
+end

data/spec/stoplight/failure_spec.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::Failure do
+  let(:error) { double }
+
+  subject(:failure) { described_class.new(error) }
+
+  describe '#to_json' do
+    let(:json) { JSON.parse(result) }
+
+    subject(:result) { failure.to_json }
+
+    it 'includes the error' do
+      expect(json['error']).to eql(error.inspect)
+    end
+
+    it 'includes the time' do
+      expect(json['time']).to eql(Time.now.to_s)
+    end
+  end
+end

data/spec/stoplight/light_spec.rb

@@ -0,0 +1,222 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::Light do
+  let(:code) { proc { code_result } }
+  let(:code_result) { double }
+  let(:name) { SecureRandom.hex }
+
+  subject(:light) { described_class.new(name, &code) }
+
+  describe '#initialize' do
+    it 'uses the default allowed errors' do
+      expect(light.allowed_errors).to eql([])
+    end
+
+    it 'sets the code' do
+      expect(light.code).to eql(code.to_proc)
+    end
+
+    it 'sets the name' do
+      expect(light.name).to eql(name.to_s)
+    end
+  end
+
+  describe '#run' do
+    subject(:result) { light.run }
+
+    it 'syncs settings' do
+      expect(Stoplight.data_store.threshold(name)).to be nil
+      result
+      expect(Stoplight.data_store.threshold(name)).to eql(
+        light.threshold)
+    end
+
+    context 'green' do
+      before { allow(light).to receive(:green?).and_return(true) }
+
+      it 'runs the code' do
+        expect(result).to eql(code_result)
+      end
+
+      it 'clears failures' do
+        Stoplight.record_failure(name, nil)
+        expect(Stoplight.failures(name)).to_not be_empty
+        result
+        expect(Stoplight.failures(name)).to be_empty
+      end
+
+      context 'with failing code' do
+        let(:code_result) { fail error }
+        let(:error) { klass.new }
+        let(:klass) { Class.new(StandardError) }
+        let(:safe_result) do
+          begin
+            result
+          rescue klass
+            nil
+          end
+        end
+
+        it 'raises the error' do
+          expect { result }.to raise_error(error)
+        end
+
+        it 'records the failure' do
+          expect(Stoplight.failures(name)).to be_empty
+          safe_result
+          expect(Stoplight.failures(name)).to_not be_empty
+        end
+
+        context do
+          before { light.with_allowed_errors([klass]) }
+
+          it 'clears failures' do
+            Stoplight.record_failure(name, nil)
+            expect(Stoplight.failures(name)).to_not be_empty
+            safe_result
+            expect(Stoplight.failures(name)).to be_empty
+          end
+        end
+      end
+    end
+
+    context 'not green' do
+      let(:fallback) { proc { fallback_result } }
+      let(:fallback_result) { double }
+
+      before do
+        light.with_fallback(&fallback)
+        allow(light).to receive(:green?).and_return(false)
+      end
+
+      it 'runs the fallback' do
+        expect(result).to eql(fallback_result)
+      end
+
+      it 'records the attempt' do
+        result
+        expect(Stoplight.data_store.attempts(name)).to eql(1)
+      end
+    end
+  end
+
+  describe '#with_allowed_errors' do
+    let(:allowed_errors) { [double] }
+
+    subject(:result) { light.with_allowed_errors(allowed_errors) }
+
+    it 'returns self' do
+      expect(result).to be light
+    end
+
+    it 'sets the allowed errors' do
+      expect(result.allowed_errors).to eql(allowed_errors)
+    end
+  end
+
+  describe '#with_fallback' do
+    let(:fallback) { proc { fallback_result } }
+    let(:fallback_result) { double }
+
+    subject(:result) { light.with_fallback(&fallback) }
+
+    it 'returns self' do
+      expect(result).to be light
+    end
+
+    it 'sets the fallback' do
+      expect(result.fallback).to eql(fallback)
+    end
+  end
+
+  describe '#with_threshold' do
+    let(:threshold) { rand(10) }
+
+    subject(:result) { light.with_threshold(threshold) }
+
+    it 'returns self' do
+      expect(result).to be light
+    end
+
+    it 'sets the threshold' do
+      expect(result.threshold).to eql(threshold)
+    end
+  end
+
+  describe '#fallback' do
+    subject(:result) { light.fallback }
+
+    it 'uses the default fallback' do
+      expect { result }.to raise_error(Stoplight::Error::NoFallback)
+    end
+  end
+
+  describe '#green?' do
+    subject(:result) { light.green? }
+
+    it 'is true' do
+      expect(result).to be true
+    end
+
+    context 'locked green' do
+      before do
+        Stoplight.set_state(name, Stoplight::DataStore::STATE_LOCKED_GREEN)
+      end
+
+      it 'is true' do
+        expect(result).to be true
+      end
+    end
+
+    context 'locked red' do
+      before do
+        Stoplight.set_state(name, Stoplight::DataStore::STATE_LOCKED_RED)
+      end
+
+      it 'is false' do
+        expect(result).to be false
+      end
+    end
+
+    context 'with failures' do
+      before do
+        light.threshold.times { Stoplight.record_failure(name, nil) }
+      end
+
+      it 'is false' do
+        expect(result).to be false
+      end
+    end
+  end
+
+  describe '#red?' do
+    subject(:result) { light.red? }
+
+    context 'green' do
+      before { allow(light).to receive(:green?).and_return(true) }
+
+      it 'is false' do
+        expect(result).to be false
+      end
+    end
+
+    context 'not green' do
+      before { allow(light).to receive(:green?).and_return(false) }
+
+      it 'is true' do
+        expect(result).to be true
+      end
+    end
+  end
+
+  describe '#threshold' do
+    subject(:result) { light.threshold }
+
+    it 'uses the default threshold' do
+      expect(result).to eql(
+        described_class.const_get(:DEFAULT_THRESHOLD))
+    end
+  end
+end

data/spec/stoplight_spec.rb

@@ -0,0 +1,128 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight do
+  let(:name) { SecureRandom.hex }
+
+  it 'forwards all data store methods' do
+    (Stoplight::DataStore::Base.new.methods - Object.methods).each do |method|
+      expect(Stoplight).to respond_to(method)
+    end
+  end
+
+  describe '::VERSION' do
+    subject(:result) { described_class.const_get(:VERSION) }
+
+    it 'is a Gem::Version' do
+      expect(result).to be_a(Gem::Version)
+    end
+  end
+
+  describe '.data_store' do
+    subject(:result) { described_class.data_store }
+
+    it 'uses the default data store' do
+      expect(result).to be_a(Stoplight::DataStore::Memory)
+    end
+
+    it 'memoizes the result' do
+      expect(result).to be described_class.data_store
+    end
+
+    context 'with a custom data store' do
+      let(:data_store) { double }
+
+      before do
+        @data_store = described_class.data_store
+        described_class.data_store(data_store)
+      end
+
+      after { described_class.data_store(@data_store) }
+
+      it 'returns the data store' do
+        expect(result).to eql(data_store)
+      end
+    end
+  end
+
+  describe '.green?' do
+    subject(:result) { described_class.green?(name) }
+
+    it 'is true' do
+      expect(result).to be true
+    end
+
+    context 'locked green' do
+      before do
+        described_class.set_state(
+          name, Stoplight::DataStore::STATE_LOCKED_GREEN)
+      end
+
+      it 'is true' do
+        expect(result).to be true
+      end
+    end
+
+    context 'locked red' do
+      before do
+        described_class.set_state(
+          name, Stoplight::DataStore::STATE_LOCKED_RED)
+      end
+
+      it 'is false' do
+        expect(result).to be false
+      end
+    end
+
+    context 'with failures' do
+      before do
+        described_class.threshold(name).times do
+          described_class.record_failure(name, nil)
+        end
+      end
+
+      it 'is false' do
+        expect(result).to be false
+      end
+    end
+  end
+
+  describe '.red?' do
+    subject(:result) { described_class.red?(name) }
+
+    context 'green' do
+      before { allow(described_class).to receive(:green?).and_return(true) }
+
+      it 'is false' do
+        expect(result).to be false
+      end
+    end
+
+    context 'not green' do
+      before { allow(described_class).to receive(:green?).and_return(false) }
+
+      it 'is true' do
+        expect(result).to be true
+      end
+    end
+  end
+
+  describe '.threshold' do
+    subject(:result) { described_class.threshold(name) }
+
+    it 'uses the default threshold' do
+      expect(result).to eql(Stoplight::Light::DEFAULT_THRESHOLD)
+    end
+
+    context 'with a custom threshold' do
+      let(:threshold) { rand(10) }
+
+      before { described_class.set_threshold(name, threshold) }
+
+      it 'uses the threshold' do
+        expect(result).to eql(threshold)
+      end
+    end
+  end
+end