stoplight 0.2.1 → 0.3.0

data/spec/stoplight/notifier/hip_chat_spec.rb

@@ -3,9 +3,10 @@
 require 'spec_helper'
 
 describe Stoplight::Notifier::HipChat do
-  subject(:notifier) { described_class.new(client, room, options) }
+  subject(:notifier) { described_class.new(client, room, format, options) }
   let(:client) { double }
   let(:room) { SecureRandom.hex }
+  let(:format) { nil }
   let(:options) { {} }
 
   describe '#notify' do
@@ -15,7 +16,19 @@ describe Stoplight::Notifier::HipChat do
     it 'sends the message to HipChat' do
       expect(client).to receive(:[]).with(room).and_return(client)
       expect(client).to receive(:send)
+        .with('Stoplight', "@all #{message}", anything)
       result
     end
+
+    context 'with a format' do
+      let(:format) { '> %s <' }
+
+      it 'formats the message' do
+        expect(client).to receive(:[]).with(room).and_return(client)
+        expect(client).to receive(:send)
+          .with('Stoplight', "> #{message} <", anything)
+        result
+      end
+    end
   end
 end

data/spec/stoplight/notifier/standard_error_spec.rb

@@ -3,16 +3,28 @@
 require 'spec_helper'
 
 describe Stoplight::Notifier::StandardError do
-  subject(:notifier) { described_class.new }
+  subject(:notifier) { described_class.new(format) }
+  let(:format) { nil }
 
-  describe '#notify' do
-    let(:message) { SecureRandom.hex }
+  before { @stderr, $stderr = $stderr, StringIO.new }
+  after { $stderr = @stderr }
 
+  describe '#notify' do
     subject(:result) { notifier.notify(message) }
+    let(:message) { SecureRandom.hex }
 
     it 'emits the message as a warning' do
-      expect(notifier).to receive(:warn).with(message)
       result
+      expect($stderr.string).to eql("#{message}\n")
+    end
+
+    context 'with a format' do
+      let(:format) { '> %s <' }
+
+      it 'formats the message' do
+        result
+        expect($stderr.string).to eql("> #{message} <\n")
+      end
     end
   end
 end

data/spec/stoplight_spec.rb

@@ -5,12 +5,6 @@ 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) }
 
@@ -75,84 +69,4 @@ describe Stoplight do
       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::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

data/spec/support/data_store.rb

@@ -1,178 +1,44 @@
 # coding: utf-8
+# rubocop:disable Metrics/LineLength
 
 shared_examples_for 'a data store' do
+  let(:name) { SecureRandom.hex }
+  let(:failure) { Stoplight::Failure.new(error, time) }
   let(:error) { error_class.new }
   let(:error_class) { Class.new(StandardError) }
-  let(:name) { SecureRandom.hex }
+  let(:time) { Time.now }
   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
+  let(:threshold) { rand(100) }
+  let(:timeout) { rand(100) }
+
+  it { expect(data_store.names).to eql([]) }
+  it { expect(data_store.clear_stale).to eql(nil) }
+  it { expect(data_store.clear(name)).to eql(nil) }
+  it { expect(data_store.sync(name)).to eql(nil) }
+  it { expect(data_store.get_color(name)).to eql(Stoplight::DataStore::COLOR_GREEN) }
+  it { expect(data_store.green?(name)).to eql(true) }
+  it { expect(data_store.yellow?(name)).to eql(false) }
+  it { expect(data_store.red?(name)).to eql(false) }
+  it { expect(data_store.get_attempts(name)).to eql(Stoplight::DataStore::DEFAULT_ATTEMPTS) }
+  it { expect(data_store.record_attempt(name)).to eql(1) }
+  it { expect(data_store.clear_attempts(name)).to eql(nil) }
+  it { expect(data_store.get_failures(name)).to eql(Stoplight::DataStore::DEFAULT_FAILURES) }
+  it { expect(data_store.record_failure(name, failure)).to eql(failure) }
+  it { expect(data_store.clear_failures(name)).to eql(nil) }
+  it { expect(data_store.get_state(name)).to eql(Stoplight::DataStore::DEFAULT_STATE) }
+  it { expect(data_store.set_state(name, state)).to eql(state) }
+  it { expect(data_store.clear_state(name)).to eql(nil) }
+  it { expect(data_store.get_threshold(name)).to eql(Stoplight::DataStore::DEFAULT_THRESHOLD) }
+  it { expect(data_store.set_threshold(name, threshold)).to eql(threshold) }
+  it { expect(data_store.clear_threshold(name)).to eql(nil) }
+  it { expect(data_store.get_timeout(name)).to eql(Stoplight::DataStore::DEFAULT_TIMEOUT) }
+  it { expect(data_store.set_timeout(name, timeout)).to eql(timeout) }
+  it { expect(data_store.clear_timeout(name)).to eql(nil) }
+
+  it 'clears stale lights' do
+    data_store.sync(name)
+    expect(data_store.names).to include(name)
+    data_store.clear_stale
+    expect(data_store.names).to_not include(name)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stoplight
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Cameron Desautels
@@ -9,8 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-20 00:00:00.000000000 Z
+date: 2014-09-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -59,28 +73,28 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.25.0
+        version: 0.26.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.25.0
+        version: 0.26.0
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -103,23 +117,27 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- lib/stoplight.rb
+- lib/stoplight/data_store.rb
 - lib/stoplight/data_store/base.rb
 - lib/stoplight/data_store/memory.rb
 - lib/stoplight/data_store/redis.rb
-- lib/stoplight/data_store.rb
 - lib/stoplight/error.rb
 - lib/stoplight/failure.rb
 - lib/stoplight/light.rb
 - lib/stoplight/mixin.rb
+- lib/stoplight/notifier.rb
 - lib/stoplight/notifier/base.rb
 - lib/stoplight/notifier/hip_chat.rb
 - lib/stoplight/notifier/standard_error.rb
-- lib/stoplight/notifier.rb
-- lib/stoplight.rb
 - spec/spec_helper.rb
 - spec/stoplight/data_store/base_spec.rb
 - spec/stoplight/data_store/memory_spec.rb
 - spec/stoplight/data_store/redis_spec.rb
+- spec/stoplight/data_store_spec.rb
 - spec/stoplight/failure_spec.rb
 - spec/stoplight/light_spec.rb
 - spec/stoplight/mixin_spec.rb
@@ -129,9 +147,6 @@ files:
 - spec/stoplight/notifier_spec.rb
 - spec/stoplight_spec.rb
 - spec/support/data_store.rb
-- CHANGELOG.md
-- LICENSE.md
-- README.md
 homepage: https://github.com/orgsync/stoplight
 licenses:
 - MIT
@@ -152,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: Traffic control for code.
@@ -161,6 +176,7 @@ test_files:
 - spec/stoplight/data_store/base_spec.rb
 - spec/stoplight/data_store/memory_spec.rb
 - spec/stoplight/data_store/redis_spec.rb
+- spec/stoplight/data_store_spec.rb
 - spec/stoplight/failure_spec.rb
 - spec/stoplight/light_spec.rb
 - spec/stoplight/mixin_spec.rb