stoplight 0.4.1 → 0.5.0

data/lib/stoplight/notifier/base.rb

@@ -3,10 +3,7 @@
 module Stoplight
   module Notifier
     class Base
-      # @param _light [Light]
-      # @param _from_color [String]
-      # @param _to_color [String]
-      def notify(_light, _from_color, _to_color)
+      def notify(_light, _from_color, _to_color, _error)
         fail NotImplementedError
       end
     end

data/lib/stoplight/notifier/hip_chat.rb

@@ -2,44 +2,29 @@
 
 module Stoplight
   module Notifier
-    # @note hipchat ~> 1.3.0
     class HipChat < Base
-      DEFAULT_FORMATTER = lambda do |light, from_color, to_color|
-        "@all Switching #{light.name} from #{from_color} to #{to_color}"
-      end
-      DEFAULT_OPTIONS = { color: 'red', message_format: 'text', notify: true }
+      DEFAULT_OPTIONS = {
+        color: 'purple',
+        message_format: 'text',
+        notify: true
+      }.freeze
+
+      attr_reader :formatter
+      attr_reader :hip_chat
+      attr_reader :options
+      attr_reader :room
 
-      # @param client [HipChat::Client]
-      # @param room [String]
-      # @param formatter [Proc, nil]
-      # @param options [Hash]
-      def initialize(client, room, formatter = nil, options = {})
-        @client = client
+      def initialize(hip_chat, room, formatter = nil, options = {})
+        @hip_chat = hip_chat
         @room = room
-        @formatter = formatter || DEFAULT_FORMATTER
+        @formatter = formatter || Default::FORMATTER
         @options = DEFAULT_OPTIONS.merge(options)
       end
 
-      def notify(light, from_color, to_color)
-        message = @formatter.call(light, from_color, to_color)
-        @client[@room].send('Stoplight', message, @options)
-      rescue *errors => error
-        raise Error::BadNotifier, error
-      end
-
-      private
-
-      def errors
-        [
-          ::HipChat::InvalidApiVersion,
-          ::HipChat::RoomMissingOwnerUserId,
-          ::HipChat::RoomNameTooLong,
-          ::HipChat::Unauthorized,
-          ::HipChat::UnknownResponseCode,
-          ::HipChat::UnknownRoom,
-          ::HipChat::UnknownUser,
-          ::HipChat::UsernameTooLong
-        ]
+      def notify(light, from_color, to_color, error)
+        message = formatter.call(light, from_color, to_color, error)
+        hip_chat[room].send('Stoplight', message, options)
+        message
       end
     end
   end

data/lib/stoplight/notifier/io.rb

@@ -1,22 +1,22 @@
 # coding: utf-8
 
+require 'stringio'
+
 module Stoplight
   module Notifier
     class IO < Base
-      DEFAULT_FORMATTER = lambda do |light, from_color, to_color|
-        "Switching #{light.name} from #{from_color} to #{to_color}"
-      end
+      attr_reader :formatter
+      attr_reader :io
 
-      # @param io [IO]
-      # @param formatter [Proc, nil]
       def initialize(io, formatter = nil)
         @io = io
-        @formatter = formatter || DEFAULT_FORMATTER
+        @formatter = formatter || Default::FORMATTER
       end
 
-      def notify(light, from_color, to_color)
-        message = @formatter.call(light, from_color, to_color)
-        @io.puts(message)
+      def notify(light, from_color, to_color, error)
+        message = formatter.call(light, from_color, to_color, error)
+        io.puts(message)
+        message
       end
     end
   end

data/lib/stoplight/state.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+
+module Stoplight
+  module State
+    UNLOCKED = 'unlocked'.freeze
+    LOCKED_GREEN = 'locked_green'.freeze
+    LOCKED_RED = 'locked_red'.freeze
+  end
+end

data/spec/spec_helper.rb

@@ -4,7 +4,6 @@ require 'coveralls'
 Coveralls.wear!
 
 require 'stoplight'
+require 'timecop'
 
-Dir.glob(File.join('.', 'spec', 'support', '**', '*.rb')).each do |filename|
-  require filename
-end
+Timecop.safe_mode = true

data/spec/stoplight/color_spec.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::Color do
+  it 'is a module' do
+    expect(described_class).to be_a(Module)
+  end
+
+  describe '::GREEN' do
+    it 'is a string' do
+      expect(Stoplight::Color::GREEN).to be_a(String)
+    end
+
+    it 'is frozen' do
+      expect(Stoplight::Color::GREEN).to be_frozen
+    end
+  end
+
+  describe '::YELLOW' do
+    it 'is a string' do
+      expect(Stoplight::Color::YELLOW).to be_a(String)
+    end
+
+    it 'is frozen' do
+      expect(Stoplight::Color::YELLOW).to be_frozen
+    end
+  end
+
+  describe '::RED' do
+    it 'is a string' do
+      expect(Stoplight::Color::RED).to be_a(String)
+    end
+
+    it 'is frozen' do
+      expect(Stoplight::Color::RED).to be_frozen
+    end
+  end
+end

data/spec/stoplight/data_store/base_spec.rb

@@ -3,42 +3,62 @@
 require 'spec_helper'
 
 describe Stoplight::DataStore::Base do
-  subject(:data_store) { described_class.new }
-
-  %w(
-    names
-    clear_stale
-    clear
-    sync
-    greenify
-    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
-    clear_threshold
-    get_timeout
-    set_timeout
-    clear_timeout
-  ).each do |method|
-    it "responds to #{method}" do
-      expect(data_store).to respond_to(method)
-    end
-
-    it "does not implement #{method}" do
-      args = [nil] * data_store.method(method).arity
-      expect { data_store.public_send(method, *args) }.to raise_error(
-        NotImplementedError)
+  let(:data_store) { described_class.new }
+
+  it 'is a class' do
+    expect(described_class).to be_a(Class)
+  end
+
+  describe '#names' do
+    it 'is not implemented' do
+      expect { data_store.names }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#get_all' do
+    it 'is not implemented' do
+      expect { data_store.get_all(nil) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#get_failures' do
+    it 'is not implemented' do
+      expect { data_store.get_failures(nil) }
+        .to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#record_failure' do
+    it 'is not implemented' do
+      expect { data_store.record_failure(nil, nil) }
+        .to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#clear_failures' do
+    it 'is not implemented' do
+      expect { data_store.clear_failures(nil) }
+        .to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#get_state' do
+    it 'is not implemented' do
+      expect { data_store.get_state(nil) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#set_state' do
+    it 'is not implemented' do
+      expect { data_store.set_state(nil, nil) }
+        .to raise_error(NotImplementedError)
+    end
+  end
+
+  describe '#clear_state' do
+    it 'is not implemented' do
+      expect { data_store.clear_state(nil) }
+        .to raise_error(NotImplementedError)
     end
   end
 end

data/spec/stoplight/data_store/memory_spec.rb

@@ -3,7 +3,125 @@
 require 'spec_helper'
 
 describe Stoplight::DataStore::Memory do
-  subject(:data_store) { described_class.new }
+  let(:data_store) { described_class.new }
+  let(:light) { Stoplight::Light.new(name) {} }
+  let(:name) { ('a'..'z').to_a.shuffle.join }
+  let(:failure) { Stoplight::Failure.new('class', 'message', Time.new) }
 
-  it_behaves_like 'a data store'
+  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
+  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
 end

data/spec/stoplight/data_store/redis_spec.rb

@@ -1,41 +1,140 @@
 # coding: utf-8
 
 require 'spec_helper'
+require 'fakeredis'
 
 describe Stoplight::DataStore::Redis do
-  subject(:data_store) { described_class.new(redis) }
+  let(:data_store) { described_class.new(redis) }
   let(:redis) { Redis.new }
+  let(:light) { Stoplight::Light.new(name) {} }
+  let(:name) { ('a'..'z').to_a.shuffle.join }
+  let(:failure) { Stoplight::Failure.new('class', 'message', Time.new) }
 
-  it_behaves_like 'a data store'
+  before { Redis::Connection::Memory.reset_all_databases }
 
-  context 'with a failing connection' do
-    let(:name) { SecureRandom.hex }
-    let(:error) { Redis::BaseConnectionError.new(message) }
-    let(:message) { SecureRandom.hex }
+  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
+  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
 
-    before { allow(redis).to receive(:hget).and_raise(error) }
+  describe '#get_failures' do
+    it 'is initially empty' do
+      expect(data_store.get_failures(light)).to eql([])
+    end
 
-    it 'reraises the error' do
-      expect { data_store.sync(name) }
-        .to raise_error(Stoplight::Error::BadDataStore)
+    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
 
-    it 'sets the message' do
-      begin
-        data_store.sync(name)
-        expect(false).to be(true)
-      rescue Stoplight::Error::BadDataStore => e
-        expect(e.message).to eql(message)
-      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 'sets the cause' do
-      begin
-        data_store.sync(name)
-        expect(false).to be(true)
-      rescue Stoplight::Error::BadDataStore => e
-        expect(e.cause).to eql(error)
-      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
 end