stoplight 4.1.0 → 5.0.1

data/spec/stoplight/light_spec.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'stringio'
-
-RSpec.describe Stoplight::Light do
-  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
-
-  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
-
-  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
-
-  describe '.default_notifiers' do
-    it 'is initially the default' do
-      expect(described_class.default_notifiers)
-        .to eql(Stoplight::Default::NOTIFIERS)
-    end
-  end
-
-  describe '.default_notifiers=' do
-    before { @default_notifiers = described_class.default_notifiers }
-    after { described_class.default_notifiers = @default_notifiers }
-
-    it 'sets the data store' do
-      notifiers = []
-      described_class.default_notifiers = notifiers
-      expect(described_class.default_notifiers).to eql(notifiers)
-    end
-  end
-
-  describe '#code' do
-    it 'reads the code' do
-      expect(light.code).to eql(code)
-    end
-  end
-
-  describe '#cool_off_time' do
-    it 'is initially the default' do
-      expect(light.cool_off_time).to eql(Stoplight::Default::COOL_OFF_TIME)
-    end
-  end
-
-  describe '#data_store' do
-    it 'is initially the default' do
-      expect(light.data_store).to eql(described_class.default_data_store)
-    end
-  end
-
-  describe '#error_handler' do
-    it 'it initially the default' do
-      expect(light.error_handler).to eql(Stoplight::Default::ERROR_HANDLER)
-    end
-  end
-
-  describe '#error_notifier' do
-    it 'it initially the default' do
-      expect(light.error_notifier)
-        .to eql(described_class.default_error_notifier)
-    end
-  end
-
-  describe '#fallback' do
-    it 'is initially the default' do
-      expect(light.fallback).to eql(Stoplight::Default::FALLBACK)
-    end
-  end
-
-  describe '#name' do
-    it 'reads the name' do
-      expect(light.name).to eql(name)
-    end
-  end
-
-  describe '#notifiers' do
-    it 'is initially the default' do
-      expect(light.notifiers).to eql(described_class.default_notifiers)
-    end
-  end
-
-  describe '#threshold' do
-    it 'is initially the default' do
-      expect(light.threshold).to eql(Stoplight::Default::THRESHOLD)
-    end
-  end
-
-  describe '#window_size' do
-    it 'is initially the default' do
-      expect(light.window_size).to eql(Stoplight::Default::WINDOW_SIZE)
-    end
-  end
-
-  describe '#with_error_handler' do
-    it 'sets the error handler' do
-      error_handler = ->(_, _) {}
-      light.with_error_handler(&error_handler)
-      expect(light.error_handler).to eql(error_handler)
-    end
-  end
-
-  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
-
-  describe '#with_fallback' do
-    it 'sets the fallback' do
-      fallback = ->(_) {}
-      light.with_fallback(&fallback)
-      expect(light.fallback).to eql(fallback)
-    end
-  end
-
-  it_behaves_like Stoplight::Configurable
-end

data/spec/stoplight/notifier/base_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::Notifier::Base do
-  let(:notifier) { described_class.new }
-
-  it 'is a class' do
-    expect(described_class).to be_a(Class)
-  end
-
-  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/generic_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::Notifier::Generic do
-  let(:light) { Stoplight::Light.new(name) {} }
-  let(:name) { ('a'..'z').to_a.shuffle.join }
-  let(:from_color) { Stoplight::Color::GREEN }
-  let(:to_color) { Stoplight::Color::RED }
-  let(:error) { nil }
-
-  it 'is a module' do
-    expect(described_class).to be_a(Module)
-  end
-
-  describe '#put' do
-    let(:notifier) { notifier_class.new(double.as_null_object) }
-    let(:notifier_class) do
-      Class.new do
-        include Stoplight::Notifier::Generic
-      end
-    end
-
-    it 'has to implement the #put method' do
-      expect do
-        notifier.notify(light, from_color, to_color, error)
-      end.to raise_error(NotImplementedError)
-    end
-  end
-
-  describe '#notify' do
-    let(:formatted_message) { 'formatted message' }
-    let(:notifier) { notifier_class.new(object) }
-    let(:notifier_class) do
-      Class.new do
-        include Stoplight::Notifier::Generic
-        def put(message)
-          object.put(message)
-        end
-      end
-
-      it 'puts formatted message' do
-        expect(formatter).to receive(:call).with(light, from_color, to_color, error) { formatted_message }
-        expect(object).to receive(:put).with(formatted_message)
-
-        expect(notifier.notify(light, from_color, to_color, error)).to eq(formatted_message)
-      end
-    end
-  end
-end

data/spec/stoplight/notifier/io_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'stringio'
-require 'stoplight/rspec'
-
-RSpec.describe Stoplight::Notifier::IO do
-  it_behaves_like 'a generic notifier'
-
-  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::Notifier::Base
-  end
-
-  describe '#io' do
-    it 'reads the IO' do
-      io = StringIO.new
-      expect(described_class.new(io).io).to eql(io)
-    end
-  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(io) }
-    let(:io) { StringIO.new }
-
-    it 'writes the message' do
-      error = nil
-      notifier.notify(light, from_color, to_color, error)
-      message = notifier.formatter.call(light, from_color, to_color, error)
-      expect(io.string).to eql("#{message}\n")
-    end
-  end
-end

data/spec/stoplight/notifier/logger_spec.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'logger'
-require 'stringio'
-require 'stoplight/rspec'
-
-RSpec.describe Stoplight::Notifier::Logger do
-  it_behaves_like 'a generic notifier'
-
-  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::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, formatter).formatter)
-        .to eql(formatter)
-    end
-  end
-
-  describe '#logger' do
-    it 'reads the logger' do
-      logger = Logger.new(StringIO.new)
-      expect(described_class.new(logger, nil).logger)
-        .to eql(logger)
-    end
-  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(Logger.new(io)) }
-    let(:io) { StringIO.new }
-
-    before do
-      notifier.notify(light, from_color, to_color, error)
-    end
-
-    subject(:result) { io.string }
-
-    context 'when no error given' do
-      let(:error) { nil }
-
-      it 'logs message' do
-        expect(result).to match(/.+#{message}/)
-      end
-    end
-
-    context 'when message with an error given' do
-      let(:error) { ZeroDivisionError.new('divided by 0') }
-
-      it 'logs message' do
-        expect(result).to match(/.+#{message}/)
-      end
-    end
-
-    def message
-      notifier.formatter.call(light, from_color, to_color, error)
-    end
-  end
-end

data/spec/stoplight/notifier_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::Notifier do
-  it 'is a module' do
-    expect(described_class).to be_a(Module)
-  end
-end

data/spec/stoplight/state_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::State do
-  it 'is a module' do
-    expect(described_class).to be_a(Module)
-  end
-
-  describe '::UNLOCKED' do
-    it 'is a string' do
-      expect(Stoplight::State::UNLOCKED).to be_a(String)
-    end
-
-    it 'is frozen' do
-      expect(Stoplight::State::UNLOCKED).to be_frozen
-    end
-  end
-
-  describe '::LOCKED_GREEN' do
-    it 'is a string' do
-      expect(Stoplight::State::LOCKED_GREEN).to be_a(String)
-    end
-
-    it 'is frozen' do
-      expect(Stoplight::State::LOCKED_GREEN).to be_frozen
-    end
-  end
-
-  describe '::LOCKED_RED' do
-    it 'is a string' do
-      expect(Stoplight::State::LOCKED_RED).to be_a(String)
-    end
-
-    it 'is frozen' do
-      expect(Stoplight::State::LOCKED_RED).to be_frozen
-    end
-  end
-end

data/spec/stoplight/version_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::VERSION do
-  it 'is a gem version' do
-    expect(described_class).to be_a(Gem::Version)
-  end
-end

data/spec/stoplight_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight do
-  it 'is a module' do
-    expect(described_class).to be_a(Module)
-  end
-end
-
-RSpec.describe 'Stoplight' do
-  let(:name) { ('a'..'z').to_a.shuffle.join }
-
-  context 'with code' do
-    subject(:light) { Stoplight(name, &code) }
-    let(:code) { -> {} }
-
-    it 'creates a stoplight' do
-      expect(light).to be_a(Stoplight::Light)
-      expect(light.name).to eql(name)
-      expect(light.code).to eql(code)
-    end
-  end
-
-  context 'without code' do
-    subject(:light) { Stoplight(name) }
-
-    it 'creates a stoplight' do
-      expect(light).to eq(Stoplight::Builder.with(name: name))
-    end
-  end
-end

data/spec/support/configurable.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples Stoplight::Configurable do
-  let(:configurable) { described_class.new(configuration) }
-
-  let(:configuration) do
-    Stoplight::Configuration.new(
-      name: name,
-      data_store: Stoplight.default_data_store,
-      notifiers: Stoplight.default_notifiers,
-      error_notifier: Stoplight.default_error_notifier,
-      cool_off_time: Stoplight::Default::COOL_OFF_TIME,
-      threshold: Stoplight::Default::THRESHOLD,
-      window_size: Stoplight::Default::WINDOW_SIZE
-    )
-  end
-
-  shared_examples 'configurable attribute' do |attribute|
-    subject(:with_attribute) do
-      configurable.__send__("with_#{attribute}", __send__(attribute))
-    end
-
-    it "configures #{attribute}" do
-      expect(with_attribute.configuration.__send__(attribute)).to eq(__send__(attribute))
-    end
-  end
-
-  describe '#with_data_store' do
-    let(:data_store) { instance_double(Stoplight::DataStore::Redis) }
-
-    include_examples 'configurable attribute', :data_store
-  end
-
-  describe '#cool_off_time' do
-    let(:cool_off_time) { 1_000 }
-
-    include_examples 'configurable attribute', :cool_off_time
-  end
-
-  describe '#with_threshold' do
-    let(:threshold) { 1_000 }
-
-    include_examples 'configurable attribute', :threshold
-  end
-
-  describe '#with_window_size' do
-    let(:window_size) { 1_000 }
-
-    include_examples 'configurable attribute', :window_size
-  end
-
-  describe '#with_notifiers' do
-    let(:notifiers) { 1_000 }
-
-    include_examples 'configurable attribute', :notifiers
-  end
-
-  describe '#with_error_notifier' do
-    let(:error_notifier) { ->(x) { x } }
-
-    subject(:with_attribute) do
-      configurable.with_error_notifier(&error_notifier)
-    end
-
-    it 'configures error notifier' do
-      expect(with_attribute.configuration.error_notifier).to eq(error_notifier)
-    end
-  end
-end

data/spec/support/data_store/base/clear_failures.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'Stoplight::DataStore::Base#clear_failures' do
-  before do
-    data_store.record_failure(light, failure)
-  end
-
-  it 'returns the failures' do
-    expect(data_store.clear_failures(light)).to contain_exactly(failure)
-  end
-
-  it 'clears the failures' do
-    expect do
-      data_store.clear_failures(light)
-    end.to change { data_store.get_failures(light) }
-      .from([failure]).to(be_empty)
-  end
-end

data/spec/support/data_store/base/clear_state.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'Stoplight::DataStore::Base#clear_state' do
-  let(:state) { 'state' }
-
-  it 'returns the state' do
-    data_store.set_state(light, state)
-
-    expect(data_store.clear_state(light)).to eql(state)
-  end
-
-  it 'clears the state' do
-    data_store.set_state(light, state)
-
-    expect do
-      data_store.clear_state(light)
-    end.to change { data_store.get_state(light) }
-      .from(state).to(Stoplight::State::UNLOCKED)
-  end
-end

data/spec/support/data_store/base/get_all.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'Stoplight::DataStore::Base#get_all' do
-  context 'when there are no errors' 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
-
-  context 'when there are errors' do
-    before do
-      data_store.record_failure(light, failure)
-    end
-
-    it 'returns the failures and the state' do
-      failures, state = data_store.get_all(light)
-
-      expect(failures).to eq([failure])
-      expect(state).to eql(Stoplight::State::UNLOCKED)
-    end
-  end
-
-  context 'when there is a failure outside of the window' do
-    let(:window_size) { 3600 }
-    let(:older_failure) { Stoplight::Failure.new('class', 'message 3', Time.new - window_size - 1) }
-
-    before do
-      light.with_window_size(window_size)
-
-      data_store.record_failure(light, older_failure)
-      data_store.record_failure(light, failure)
-    end
-
-    it 'returns the failures within window and the state' do
-      failures, state = data_store.get_all(light)
-
-      expect(failures).to contain_exactly(failure)
-      expect(state).to eql(Stoplight::State::UNLOCKED)
-    end
-  end
-end

data/spec/support/data_store/base/get_failures.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'Stoplight::DataStore::Base#get_failures' do
-  it 'is initially empty' do
-    expect(data_store.get_failures(light)).to eql([])
-  end
-
-  it 'handles invalid JSON' do
-    expect { data_store.record_failure(light, failure) }
-      .to change { data_store.get_failures(light) }
-      .from(be_empty)
-      .to(contain_exactly(failure))
-  end
-
-  context 'when there is a failure outside of the window' do
-    let(:window_size) { 3600 }
-    let(:older_failure) { Stoplight::Failure.new('class', 'message 3', Time.new - window_size - 1) }
-
-    before do
-      light.with_window_size(window_size)
-
-      data_store.record_failure(light, failure)
-      data_store.record_failure(light, older_failure)
-    end
-
-    it 'returns failures withing given window' do
-      expect(data_store.get_failures(light)).to contain_exactly(failure)
-    end
-  end
-end

data/spec/support/data_store/base/get_state.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'Stoplight::DataStore::Base#get_state' do
-  it 'is initially unlocked' do
-    expect(data_store.get_state(light)).to eql(Stoplight::State::UNLOCKED)
-  end
-end

data/spec/support/data_store/base/names.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'Stoplight::DataStore::Base#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
-
-  it 'supports names containing colons' do
-    light = Stoplight::Light.new('http://api.example.com/some/action')
-    data_store.record_failure(light, failure)
-    expect(data_store.names).to eql([light.name])
-  end
-end