stoplight 0.1.0 → 0.2.0

data/spec/stoplight/data_store/redis_spec.rb

@@ -4,187 +4,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(redis) }
+  let(:redis) { Redis.new }
 
-  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
+  it_behaves_like 'a data store'
 end

data/spec/stoplight/light_spec.rb

@@ -89,6 +89,9 @@ describe Stoplight::Light do
       before do
         light.with_fallback(&fallback)
         allow(light).to receive(:green?).and_return(false)
+        Stoplight.notifiers.each do |notifier|
+          allow(notifier).to receive(:notify)
+        end
       end
 
       it 'runs the fallback' do
@@ -99,6 +102,24 @@ describe Stoplight::Light do
         result
         expect(Stoplight.data_store.attempts(name)).to eql(1)
       end
+
+      it 'notifies' do
+        result
+        Stoplight.notifiers.each do |notifier|
+          expect(notifier).to have_received(:notify)
+        end
+      end
+
+      context 'with an attempt' do
+        before { allow(Stoplight).to receive(:attempts).and_return(1) }
+
+        it 'does not notify' do
+          result
+          Stoplight.notifiers.each do |notifier|
+            expect(notifier).to_not have_received(:notify)
+          end
+        end
+      end
     end
   end
 
@@ -149,7 +170,7 @@ describe Stoplight::Light do
     subject(:result) { light.fallback }
 
     it 'uses the default fallback' do
-      expect { result }.to raise_error(Stoplight::Error::NoFallback)
+      expect { result }.to raise_error(Stoplight::Error::RedLight)
     end
   end
 
@@ -215,8 +236,7 @@ describe Stoplight::Light do
     subject(:result) { light.threshold }
 
     it 'uses the default threshold' do
-      expect(result).to eql(
-        described_class.const_get(:DEFAULT_THRESHOLD))
+      expect(result).to eql(Stoplight::DEFAULT_THRESHOLD)
     end
   end
 end

data/spec/stoplight/mixin_spec.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::Mixin do
+  subject(:klass) { Class.new.extend(described_class) }
+
+  describe '#stoplight' do
+    subject(:result) { klass.stoplight(name, &code) }
+    let(:name) { SecureRandom.hex }
+    let(:code) { proc { code_result } }
+    let(:code_result) { double }
+
+    let(:light) { double }
+
+    before do
+      allow(Stoplight::Light).to receive(:new).and_return(light)
+      allow(light).to receive(:run).and_return(code.call)
+    end
+
+    it 'calls .new' do
+      expect(Stoplight::Light).to receive(:new)
+      result
+    end
+
+    it 'calls #run' do
+      expect(light).to receive(:run)
+      result
+    end
+
+    it 'returns the result of #run' do
+      expect(result).to eql(code_result)
+    end
+  end
+end

data/spec/stoplight/notifier/base_spec.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::Notifier::Base do
+  subject(:notifier) { described_class.new }
+
+  %w(
+    notify
+  ).each do |method|
+    it "responds to #{method}" do
+      expect(notifier).to respond_to(method)
+    end
+
+    it "does not implement #{method}" do
+      args = [nil] * notifier.method(method).arity
+      expect { notifier.public_send(method, *args) }.to raise_error(
+        NotImplementedError)
+    end
+  end
+end

data/spec/stoplight/notifier/hip_chat_spec.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::Notifier::HipChat do
+  subject(:notifier) { described_class.new(client, room, options) }
+  let(:client) { double }
+  let(:room) { SecureRandom.hex }
+  let(:options) { {} }
+
+  describe '#notify' do
+    subject(:result) { notifier.notify(message) }
+    let(:message) { SecureRandom.hex }
+
+    it 'sends the message to HipChat' do
+      expect(client).to receive(:[]).with(room).and_return(client)
+      expect(client).to receive(:send)
+      result
+    end
+  end
+end

data/spec/stoplight/notifier/standard_error_spec.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::Notifier::StandardError do
+  subject(:notifier) { described_class.new }
+
+  describe '#notify' do
+    let(:message) { SecureRandom.hex }
+
+    subject(:result) { notifier.notify(message) }
+
+    it 'emits the message as a warning' do
+      expect(notifier).to receive(:warn).with(message)
+      result
+    end
+  end
+end

data/spec/stoplight/notifier_spec.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::Notifier do
+end

data/spec/stoplight_spec.rb

@@ -35,10 +35,10 @@ describe Stoplight do
 
       before do
         @data_store = described_class.data_store
-        described_class.data_store(data_store)
+        described_class.data_store = data_store
       end
 
-      after { described_class.data_store(@data_store) }
+      after { described_class.data_store = @data_store }
 
       it 'returns the data store' do
         expect(result).to eql(data_store)
@@ -46,6 +46,36 @@ describe Stoplight do
     end
   end
 
+  describe '.notifiers' do
+    subject(:result) { described_class.notifiers }
+
+    it 'uses the default notifier' do
+      expect(result).to be_an(Array)
+      expect(result.size).to eql(1)
+      expect(result.first).to be_a(Stoplight::Notifier::StandardError)
+    end
+
+    it 'memoizes the result' do
+      expect(result).to be described_class.notifiers
+    end
+
+    context 'with custom notifiers' do
+      let(:notifiers) { [notifier] }
+      let(:notifier) { double }
+
+      before do
+        @notifiers = described_class.notifiers
+        described_class.notifiers = notifiers
+      end
+
+      after { described_class.notifiers = @notifiers }
+
+      it 'returns the notifiers' do
+        expect(result).to eql(notifiers)
+      end
+    end
+  end
+
   describe '.green?' do
     subject(:result) { described_class.green?(name) }
 
@@ -112,7 +142,7 @@ describe Stoplight do
     subject(:result) { described_class.threshold(name) }
 
     it 'uses the default threshold' do
-      expect(result).to eql(Stoplight::Light::DEFAULT_THRESHOLD)
+      expect(result).to eql(Stoplight::DEFAULT_THRESHOLD)
     end
 
     context 'with a custom threshold' do

data/spec/support/data_store.rb

@@ -0,0 +1,178 @@
+# coding: utf-8
+
+shared_examples_for 'a data store' 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) }
+
+  it 'is a DataStore::Base' do
+    expect(data_store).to be_a(Stoplight::DataStore::Base)
+  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 do
+        @data_store = Stoplight.data_store
+        Stoplight.data_store = data_store
+        Stoplight::Light.new(name) {}.run
+      end
+      after { Stoplight.data_store = @data_store }
+
+      it 'includes the name' do
+        expect(result).to include(name)
+      end
+    end
+  end
+
+  context 'attempts' do
+    describe '#attempts' do
+      subject(:result) { data_store.attempts(name) }
+
+      it 'returns an integer' do
+        expect(result).to be_an(Integer)
+      end
+
+      context 'with an attempt' do
+        it 'includes the attempt' do
+          attempts = data_store.attempts(name)
+          data_store.record_attempt(name)
+          expect(result).to be > attempts
+        end
+      end
+    end
+
+    describe '#clear_attempts' do
+      subject(:result) { data_store.clear_attempts(name) }
+
+      context 'with an attempt' do
+        before { data_store.record_attempt(name) }
+
+        it 'clears the attempts' do
+          result
+          expect(data_store.attempts(name)).to eql(0)
+        end
+      end
+    end
+
+    describe '#record_attempt' do
+      subject(:result) { data_store.record_attempt(name) }
+
+      it 'records the attempt' do
+        attempts = data_store.attempts(name)
+        result
+        expect(data_store.attempts(name)).to eql(attempts + 1)
+      end
+    end
+  end
+
+  context 'failures' do
+    describe '#clear_failures' do
+      subject(:result) { data_store.clear_failures(name) }
+
+      context 'with a failure' do
+        before { data_store.record_failure(name, error) }
+
+        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 array' do
+        expect(result).to be_an(Array)
+      end
+
+      context 'with a failure' do
+        it 'includes the failure' do
+          failures = data_store.failures(name)
+          data_store.record_failure(name, error)
+          expect(result.size).to be > failures.size
+        end
+      end
+    end
+
+    describe '#record_failure' do
+      subject(:result) { data_store.record_failure(name, error) }
+
+      it 'records the failure' do
+        failures = data_store.failures(name)
+        result
+        expect(data_store.failures(name).size).to eql(failures.size + 1)
+      end
+    end
+  end
+
+  context 'state' do
+    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 '#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
+  end
+
+  context 'threshold' do
+    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 '#threshold' do
+      subject(:result) { data_store.threshold(name) }
+
+      it 'returns nil' do
+        expect(result).to eql(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
+end