stoplight 0.4.1 → 0.5.0

data/spec/stoplight/light_spec.rb

@@ -1,228 +1,180 @@
 # coding: utf-8
-# rubocop:disable Metrics/LineLength
 
 require 'spec_helper'
 
 describe Stoplight::Light do
-  before do
-    @notifiers = Stoplight.notifiers
-    Stoplight.notifiers = [Stoplight::Notifier::IO.new(StringIO.new)]
-  end
-  after { Stoplight.notifiers = @notifiers }
-
-  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) { 1 + 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)
+  let(:light) { described_class.new(name, &code) }
+  let(:name) { ('a'..'z').to_a.shuffle.join }
+  let(:code) { -> {} }
+
+  it 'is a class' do
+    expect(described_class).to be_a(Class)
+  end
+
+  describe '.default_data_store' do
+    it 'is initially the default' do
+      expect(described_class.default_data_store)
+        .to eql(Stoplight::Default::DATA_STORE)
+    end
+  end
+
+  describe '.default_data_store=' do
+    before { @default_data_store = described_class.default_data_store }
+    after { described_class.default_data_store = @default_data_store }
+
+    it 'sets the data store' do
+      data_store = Stoplight::DataStore::Memory.new
+      described_class.default_data_store = data_store
+      expect(described_class.default_data_store).to eql(data_store)
+    end
   end
-
-  it 'sets the fallback' do
-    light.with_fallback(&fallback)
-    expect(light.fallback).to eql(fallback)
-  end
-
-  it 'sets the threshold' do
-    light.with_threshold(threshold)
-    expect(light.threshold).to eql(threshold)
+
+  describe '.default_error_notifier' do
+    it 'is initially the default' do
+      expect(described_class.default_error_notifier)
+        .to eql(Stoplight::Default::ERROR_NOTIFIER)
+    end
   end
 
-  it 'sets the timeout' do
-    light.with_timeout(timeout)
-    expect(light.timeout).to eql(timeout)
+  describe '.default_error_notifier=' do
+    before { @default_error_notifier = described_class.default_error_notifier }
+    after { described_class.default_error_notifier = @default_error_notifier }
+
+    it 'sets the error notifier' do
+      default_error_notifier = -> _ {}
+      described_class.default_error_notifier = default_error_notifier
+      expect(described_class.default_error_notifier)
+        .to eql(default_error_notifier)
+    end
   end
 
-  context 'failing' do
-    let(:code_result) { fail error }
-
-    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 'with allowed errors' do
-      before { light.with_allowed_errors(allowed_errors) }
-
-      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
+  describe '.default_notifiers' do
+    it 'is initially the default' do
+      expect(described_class.default_notifiers)
+        .to eql(Stoplight::Default::NOTIFIERS)
     end
+  end
 
-    context 'with fallback' do
-      before { light.with_fallback(&fallback) }
-
-      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
-
-    context 'with timeout' do
-      before { light.with_timeout(-1) }
-
-      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
-
-  context 'conditionally failing' do
-    let(:code_result) { fail error if @fail }
-    let(:name) { 'failing' }
-
-    it 'clears the attempts' do
-      @fail = true
-      light.threshold.succ.times do
-        begin
-          light.run
-        rescue error_class, Stoplight::Error::RedLight
-          nil
-        end
-      end
+  describe '.default_notifiers=' do
+    before { @default_notifiers = described_class.default_notifiers }
+    after { described_class.default_notifiers = @default_notifiers }
 
-      @fail = false
-      Stoplight.data_store.set_timeout(light.name, 0)
-      light.run
+    it 'sets the data store' do
+      notifiers = []
+      described_class.default_notifiers = notifiers
+      expect(described_class.default_notifiers).to eql(notifiers)
+    end
+  end
 
-      expect(Stoplight.data_store.get_attempts(light.name)).to eq(0)
+  describe '#allowed_errors' do
+    it 'is initially the default' do
+      expect(light.allowed_errors).to eql(Stoplight::Default::ALLOWED_ERRORS)
     end
   end
 
-  context 'with Redis' do
-    let(:data_store) { Stoplight::DataStore::Redis.new(redis) }
-    let(:redis) { Redis.new }
+  describe '#code' do
+    it 'reads the code' do
+      expect(light.code).to eql(code)
+    end
+  end
 
-    before do
-      @data_store = Stoplight.data_store
-      Stoplight.data_store = data_store
+  describe '#data_store' do
+    it 'is initially the default' do
+      expect(light.data_store).to eql(described_class.default_data_store)
     end
-    after { Stoplight.data_store = @data_store }
+  end
 
-    context 'with a failing connection' do
-      let(:error) { Stoplight::Error::BadDataStore.new(cause) }
-      let(:cause) { Redis::BaseConnectionError.new(message) }
-      let(:message) { SecureRandom.hex }
+  describe '#error_notifier' do
+    it 'it initially the default' do
+      expect(light.error_notifier)
+        .to eql(described_class.default_error_notifier)
+    end
+  end
 
-      before { allow(data_store).to receive(:sync).and_raise(error) }
+  describe '#fallback' do
+    it 'is initially the default' do
+      expect(light.fallback).to eql(Stoplight::Default::FALLBACK)
+    end
+  end
 
-      before { @stderr, $stderr = $stderr, StringIO.new }
-      after { $stderr = @stderr }
+  describe '#name' do
+    it 'reads the name' do
+      expect(light.name).to eql(name)
+    end
+  end
 
-      it 'does not raise an error' do
-        expect { light.run }.to_not raise_error
-      end
+  describe '#notifiers' do
+    it 'is initially the default' do
+      expect(light.notifiers).to eql(described_class.default_notifiers)
+    end
+  end
 
-      it 'switches to an in-memory data store' do
-        light.run
-        expect(Stoplight.data_store).to_not eql(data_store)
-        expect(Stoplight.data_store).to be_a(Stoplight::DataStore::Memory)
-      end
-
-      it 'syncs the light in the new data store' do
-        expect_any_instance_of(Stoplight::DataStore::Memory)
-          .to receive(:sync).with(light.name)
-        light.run
-      end
+  describe '#threshold' do
+    it 'is initially the default' do
+      expect(light.threshold).to eql(Stoplight::Default::THRESHOLD)
+    end
+  end
 
-      it 'warns to STDERR' do
-        light.run
-        expect($stderr.string).to eql("#{cause}\n")
-      end
+  describe '#timeout' do
+    it 'is initially the default' do
+      expect(light.timeout).to eql(Stoplight::Default::TIMEOUT)
     end
-  end
-
-  context 'with HipChat' do
-    let(:notifier) { Stoplight::Notifier::HipChat.new(client, room_name) }
-    let(:client) { double(HipChat::Client) }
-    let(:room_name) { SecureRandom.hex }
-    let(:room) { double(HipChat::Room) }
+  end
 
-    before do
-      @notifiers = Stoplight.notifiers
-      Stoplight.notifiers = [notifier]
-      allow(client).to receive(:[]).with(room_name).and_return(room)
+  describe '#with_allowed_errors' do
+    it 'adds the allowed errors to the default' do
+      allowed_errors = [StandardError]
+      light.with_allowed_errors(allowed_errors)
+      expect(light.allowed_errors)
+        .to eql(Stoplight::Default::ALLOWED_ERRORS + allowed_errors)
     end
+  end
 
-    after { Stoplight.notifiers = @notifiers }
-
-    context 'with a failing client' do
-      subject(:result) do
-        begin
-          light.run
-        rescue Stoplight::Error::RedLight
-          nil
-        end
-      end
+  describe '#with_data_store' do
+    it 'sets the data store' do
+      data_store = Stoplight::DataStore::Memory.new
+      light.with_data_store(data_store)
+      expect(light.data_store).to eql(data_store)
+    end
+  end
 
-      let(:error_class) { HipChat::Unauthorized }
+  describe '#with_error_notifier' do
+    it 'sets the error notifier' do
+      error_notifier = -> _ {}
+      light.with_error_notifier(&error_notifier)
+      expect(light.error_notifier).to eql(error_notifier)
+    end
+  end
 
-      before do
-        Stoplight.data_store.set_state(
-          light.name, Stoplight::DataStore::STATE_LOCKED_RED)
-        allow(room).to receive(:send).with(
-          'Stoplight',
-          /\A@all /,
-          hash_including(color: 'red')
-        ).and_raise(error)
-        @stderr = $stderr
-        $stderr = StringIO.new
-      end
+  describe '#with_fallback' do
+    it 'sets the fallback' do
+      fallback = -> _ {}
+      light.with_fallback(&fallback)
+      expect(light.fallback).to eql(fallback)
+    end
+  end
 
-      after { $stderr = @stderr }
+  describe '#with_notifiers' do
+    it 'sets the notifiers' do
+      notifiers = [Stoplight::Notifier::IO.new(StringIO.new)]
+      light.with_notifiers(notifiers)
+      expect(light.notifiers).to eql(notifiers)
+    end
+  end
 
-      it 'does not raise an error' do
-        expect { result }.to_not raise_error
-      end
+  describe '#with_threshold' do
+    it 'sets the threshold' do
+      threshold = 12
+      light.with_threshold(threshold)
+      expect(light.threshold).to eql(threshold)
+    end
+  end
 
-      it 'warns to STDERR' do
-        result
-        expect($stderr.string).to eql("#{error}\n")
-      end
+  describe '#with_timeout' do
+    it 'sets the timeout' do
+      timeout = 1.2
+      light.with_timeout(timeout)
+      expect(light.timeout).to eql(timeout)
     end
   end
 end

data/spec/stoplight/notifier/base_spec.rb

@@ -3,19 +3,16 @@
 require 'spec_helper'
 
 describe Stoplight::Notifier::Base do
-  subject(:notifier) { described_class.new }
+  let(:notifier) { described_class.new }
 
-  %w(
-    notify
-  ).each do |method|
-    it "responds to #{method}" do
-      expect(notifier).to respond_to(method)
-    end
+  it 'is a class' do
+    expect(described_class).to be_a(Module)
+  end
 
-    it "does not implement #{method}" do
-      args = [nil] * notifier.method(method).arity
-      expect { notifier.public_send(method, *args) }.to raise_error(
-        NotImplementedError)
+  describe '#notify' do
+    it 'is not implemented' do
+      expect { notifier.notify(nil, nil, nil, nil) }
+        .to raise_error(NotImplementedError)
     end
   end
 end

data/spec/stoplight/notifier/hip_chat_spec.rb

@@ -1,74 +1,85 @@
 # coding: utf-8
 
 require 'spec_helper'
+require 'hipchat'
 
 describe Stoplight::Notifier::HipChat do
-  subject(:notifier) { described_class.new(client, room, formatter, options) }
-  let(:client) { double }
-  let(:room) { SecureRandom.hex }
-  let(:formatter) { nil }
-  let(:options) { {} }
+  it 'is a class' do
+    expect(described_class).to be_a(Module)
+  end
 
-  describe '#notify' do
-    subject(:result) { notifier.notify(light, from_color, to_color) }
-    let(:light) { Stoplight::Light.new(light_name, &light_code) }
-    let(:light_name) { SecureRandom.hex }
-    let(:light_code) { -> {} }
-    let(:from_color) { Stoplight::DataStore::COLOR_GREEN }
-    let(:to_color) { Stoplight::DataStore::COLOR_RED }
+  it 'is a subclass of Base' do
+    expect(described_class).to be < Stoplight::Notifier::Base
+  end
+
+  describe '#formatter' do
+    it 'is initially the default' do
+      expect(described_class.new(nil, nil).formatter)
+        .to eql(Stoplight::Default::FORMATTER)
+    end
+
+    it 'reads the formatter' do
+      formatter = proc {}
+      expect(described_class.new(nil, nil, formatter).formatter)
+        .to eql(formatter)
+    end
+  end
 
-    it 'sends the message to HipChat' do
-      expect(client).to receive(:[]).with(room).and_return(client)
-      expect(client).to receive(:send).with(
-        'Stoplight',
-        "@all Switching #{light.name} from #{from_color} to #{to_color}",
-        anything)
-      result
+  describe '#hip_chat' do
+    it 'reads the HipChat client' do
+      hip_chat = HipChat::Client.new('API token')
+      expect(described_class.new(hip_chat, nil).hip_chat)
+        .to eql(hip_chat)
     end
+  end
 
-    context 'with a formatter' do
-      let(:formatter) { ->(l, f, t) { "#{l.name} #{f} #{t}" } }
+  describe '#options' do
+    it 'is initially the default' do
+      expect(described_class.new(nil, nil).options)
+        .to eql(Stoplight::Notifier::HipChat::DEFAULT_OPTIONS)
+    end
 
-      it 'formats the message' do
-        expect(client).to receive(:[]).with(room).and_return(client)
-        expect(client).to receive(:send).with(
-          'Stoplight',
-          "#{light.name} #{from_color} #{to_color}",
-          anything)
-        result
-      end
+    it 'reads the options' do
+      options = { key: :value }
+      expect(described_class.new(nil, nil, nil, options).options)
+        .to eql(Stoplight::Notifier::HipChat::DEFAULT_OPTIONS.merge(options))
     end
+  end
 
-    context 'failing' do
-      let(:error) { HipChat::UnknownResponseCode.new(message) }
-      let(:message) { SecureRandom.hex }
+  describe '#room' do
+    it 'reads the room' do
+      room = 'Notifications'
+      expect(described_class.new(nil, room).room).to eql(room)
+    end
+  end
 
-      before do
-        allow(client).to receive(:[]).with(room).and_return(client)
-        allow(client).to receive(:send).and_raise(error)
-      end
+  describe '#notify' do
+    let(:light) { Stoplight::Light.new(name, &code) }
+    let(:name) { ('a'..'z').to_a.shuffle.join }
+    let(:code) { -> {} }
+    let(:from_color) { Stoplight::Color::GREEN }
+    let(:to_color) { Stoplight::Color::RED }
+    let(:notifier) { described_class.new(hip_chat, room) }
+    let(:hip_chat) { double(HipChat::Client) }
+    let(:room) { ('a'..'z').to_a.shuffle.join }
 
-      it 'reraises the error' do
-        expect { result }.to raise_error(Stoplight::Error::BadNotifier)
-      end
+    before do
+      tmp = double
+      expect(hip_chat).to receive(:[]).with(room).and_return(tmp)
+      expect(tmp).to receive(:send)
+        .with('Stoplight', kind_of(String), kind_of(Hash)).and_return(true)
+    end
 
-      it 'sets the message' do
-        begin
-          result
-          expect(false).to be(true)
-        rescue Stoplight::Error::BadNotifier => e
-          expect(e.message).to eql(message)
-        end
-      end
+    it 'returns the message' do
+      error = nil
+      expect(notifier.notify(light, from_color, to_color, error))
+        .to eql(notifier.formatter.call(light, from_color, to_color, error))
+    end
 
-      it 'sets the cause' do
-        begin
-          result
-          expect(false).to be(true)
-        rescue Stoplight::Error::BadNotifier => e
-          expect(e.cause).to eql(error)
-        end
-      end
+    it 'returns the message with an error' do
+      error = ZeroDivisionError.new('divided by 0')
+      expect(notifier.notify(light, from_color, to_color, error))
+        .to eql(notifier.formatter.call(light, from_color, to_color, error))
     end
   end
 end