stoplight 0.2.1 → 0.3.0

data/lib/stoplight/notifier/hip_chat.rb

@@ -4,23 +4,21 @@ module Stoplight
   module Notifier
     # @note hipchat ~> 1.3.0
     class HipChat < Base
+      DEFAULT_FORMAT = '@all %s'
+      DEFAULT_OPTIONS = { color: 'red', message_format: 'text', notify: true }
+
       # @param client [HipChat::Client]
       # @param room [String]
       # @param options [Hash]
-      def initialize(client, room, options = {})
+      def initialize(client, room, format = nil, options = {})
         @client = client
         @room = room
-        @options = default_options.merge(options)
+        @format = format || DEFAULT_FORMAT
+        @options = DEFAULT_OPTIONS.merge(options)
       end
 
       def notify(message)
-        @client[@room].send('Stoplight', "@all #{message}", @options)
-      end
-
-      private
-
-      def default_options
-        { color: 'red', message_format: 'text', notify: true }
+        @client[@room].send('Stoplight', @format % message, @options)
       end
     end
   end

data/lib/stoplight/notifier/standard_error.rb

@@ -3,8 +3,14 @@
 module Stoplight
   module Notifier
     class StandardError < Base
+      DEFAULT_FORMAT = '%s'
+
+      def initialize(format = nil)
+        @format = format || DEFAULT_FORMAT
+      end
+
       def notify(message)
-        warn(message)
+        warn(@format % message)
       end
     end
   end

data/spec/stoplight/data_store/base_spec.rb

@@ -6,19 +6,29 @@ describe Stoplight::DataStore::Base do
   subject(:data_store) { described_class.new }
 
   %w(
-    attempts
-    clear_attempts
-    clear_failures
-    delete
-    failures
     names
-    purge
+    clear_stale
+    clear
+    sync
+    green?
+    yellow?
+    red?
+    get_color
+    get_attempts
     record_attempt
+    clear_attempts
+    get_failures
     record_failure
+    clear_failures
+    get_state
     set_state
+    clear_state
+    get_threshold
     set_threshold
-    state
-    threshold
+    clear_threshold
+    get_timeout
+    set_timeout
+    clear_timeout
   ).each do |method|
     it "responds to #{method}" do
       expect(data_store).to respond_to(method)

data/spec/stoplight/data_store_spec.rb

@@ -0,0 +1,60 @@
+# coding: utf-8
+
+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
+  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
+  end
+end

data/spec/stoplight/failure_spec.rb

@@ -3,21 +3,47 @@
 require 'spec_helper'
 
 describe Stoplight::Failure do
-  let(:error) { double }
+  subject(:failure) { described_class.new(error, time) }
+  let(:error) { error_class.new(error_message) }
+  let(:error_class) { StandardError }
+  let(:error_message) { SecureRandom.hex }
+  let(:time) { Time.now }
 
-  subject(:failure) { described_class.new(error) }
+  describe '.from_json' do
+    subject(:result) { described_class.from_json(json) }
+    let(:json) { failure.to_json }
 
-  describe '#to_json' do
-    let(:json) { JSON.parse(result) }
+    it do
+      expect(result.error).to eq(failure.error)
+      expect(result.time).to be_within(1).of(failure.time)
+    end
+  end
+
+  describe '#initialize' do
+    it 'sets the error' do
+      expect(failure.error).to eql(error)
+    end
 
-    subject(:result) { failure.to_json }
+    it 'sets the time' do
+      expect(failure.time).to eql(time)
+    end
+
+    context 'without a time' do
+      let(:time) { nil }
 
-    it 'includes the error' do
-      expect(json['error']).to eql(error.inspect)
+      it 'uses the default time' do
+        expect(failure.time).to be_within(1).of(Time.now)
+      end
     end
+  end
+
+  describe '#to_json' do
+    subject(:json) { failure.to_json }
+    let(:data) { JSON.load(json) }
 
-    it 'includes the time' do
-      expect(json['time']).to eql(Time.now.to_s)
+    it 'converts to JSON' do
+      expect(data['error']).to eql(error.inspect)
+      expect(data['time']).to eql(time.inspect)
     end
   end
 end

data/spec/stoplight/light_spec.rb

@@ -1,242 +1,122 @@
 # coding: utf-8
+# rubocop:disable Metrics/LineLength
 
 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
+  before do
+    @notifiers = Stoplight.notifiers
+    Stoplight.notifiers = []
   end
+  after { Stoplight.notifiers = @notifiers }
 
-  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)
-        Stoplight.notifiers.each do |notifier|
-          allow(notifier).to receive(:notify)
-        end
-      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
-
-      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
-
-  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
+  subject(:light) { described_class.new(name, &code) }
+  let(:allowed_errors) { [error_class] }
+  let(:code_result) { double }
+  let(:code) { -> { code_result } }
+  let(:error_class) { Class.new(StandardError) }
+  let(:error) { error_class.new(message) }
+  let(:fallback_result) { double }
+  let(:fallback) { -> { fallback_result } }
+  let(:message) { SecureRandom.hex }
+  let(:name) { SecureRandom.hex }
+  let(:threshold) { rand(100) }
+  let(:timeout) { rand(100) }
+
+  it { expect(light.run).to eql(code_result) }
+  it { expect(light.with_allowed_errors(allowed_errors)).to equal(light) }
+  it { expect(light.with_fallback(&fallback)).to equal(light) }
+  it { expect(light.with_threshold(threshold)).to equal(light) }
+  it { expect(light.with_timeout(timeout)).to equal(light) }
+  it { expect { light.fallback }.to raise_error(Stoplight::Error::RedLight) }
+  it { expect(light.allowed_errors).to eql([]) }
+  it { expect(light.code).to eql(code) }
+  it { expect(light.name).to eql(name) }
+  it { expect(light.color).to eql(Stoplight::DataStore::COLOR_GREEN) }
+  it { expect(light.green?).to eql(true) }
+  it { expect(light.yellow?).to eql(false) }
+  it { expect(light.red?).to eql(false) }
+  it { expect(light.threshold).to eql(Stoplight::DataStore::DEFAULT_THRESHOLD) }
+  it { expect(light.timeout).to eql(Stoplight::DataStore::DEFAULT_TIMEOUT) }
+
+  it 'sets the allowed errors' do
+    light.with_allowed_errors(allowed_errors)
+    expect(light.allowed_errors).to eql(allowed_errors)
   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
+  it 'sets the fallback' do
+    light.with_fallback(&fallback)
+    expect(light.fallback).to eql(fallback)
   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
+  it 'sets the threshold' do
+    light.with_threshold(threshold)
+    expect(light.threshold).to eql(threshold)
   end
 
-  describe '#fallback' do
-    subject(:result) { light.fallback }
-
-    it 'uses the default fallback' do
-      expect { result }.to raise_error(Stoplight::Error::RedLight)
-    end
+  it 'sets the timeout' do
+    light.with_timeout(timeout)
+    expect(light.timeout).to eql(timeout)
   end
 
-  describe '#green?' do
-    subject(:result) { light.green? }
+  context 'failing' do
+    let(:code_result) { fail error }
 
-    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
+    it 'switches to red' do
+      light.threshold.times do
+        expect(light.green?).to eql(true)
+        expect { light.run }.to raise_error(error_class)
       end
+      expect(light.red?).to eql(true)
+      expect { light.run }.to raise_error(Stoplight::Error::RedLight)
     end
 
-    context 'locked red' do
-      before do
-        Stoplight.set_state(name, Stoplight::DataStore::STATE_LOCKED_RED)
-      end
+    context 'with allowed errors' do
+      before { light.with_allowed_errors(allowed_errors) }
 
-      it 'is false' do
-        expect(result).to be false
+      it 'stays green' do
+        light.threshold.times do
+          expect(light.green?).to eql(true)
+          expect { light.run }.to raise_error(error_class)
+        end
+        expect(light.green?).to eql(true)
+        expect { light.run }.to raise_error(error_class)
       end
     end
 
-    context 'with failures' do
-      before do
-        light.threshold.times { Stoplight.record_failure(name, nil) }
-      end
+    context 'with fallback' do
+      before { light.with_fallback(&fallback) }
 
-      it 'is false' do
-        expect(result).to be false
+      it 'calls the fallback' do
+        light.threshold.times do
+          expect(light.green?).to eql(true)
+          expect { light.run }.to raise_error(error_class)
+        end
+        expect(light.red?).to eql(true)
+        expect(light.run).to eql(fallback_result)
       end
     end
-  end
-
-  describe '#red?' do
-    subject(:result) { light.red? }
 
-    context 'green' do
-      before { allow(light).to receive(:green?).and_return(true) }
+    context 'with threshold' do
+      before { light.with_threshold(0) }
 
-      it 'is false' do
-        expect(result).to be false
+      it 'stays red' do
+        expect(light.red?).to eql(true)
+        expect { light.run }.to raise_error(Stoplight::Error::RedLight)
       end
     end
 
-    context 'not green' do
-      before { allow(light).to receive(:green?).and_return(false) }
+    context 'with timeout' do
+      before { light.with_timeout(-1) }
 
-      it 'is true' do
-        expect(result).to be true
+      it 'switch to yellow' do
+        light.threshold.times do
+          expect(light.green?).to eql(true)
+          expect { light.run }.to raise_error(error_class)
+        end
+        expect(light.yellow?).to eql(true)
+        expect { light.run }.to raise_error(error_class)
       end
     end
   end
-
-  describe '#threshold' do
-    subject(:result) { light.threshold }
-
-    it 'uses the default threshold' do
-      expect(result).to eql(Stoplight::DEFAULT_THRESHOLD)
-    end
-  end
 end