stoplight 4.1.0 → 5.0.1

data/spec/stoplight/color_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.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/configurable_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::Configurable do
-  describe '#with' do
-    subject(:configurable) { configurable_class.new }
-
-    let(:configurable_class) do
-      Class.new do
-        include Stoplight::Configurable
-
-        def configuration
-          Stoplight::Configuration.new(name: 'foo')
-        end
-      end
-    end
-
-    it 'raises NotImplementedError' do
-      expect do
-        configurable.with_data_store(nil)
-      end.to raise_error(NotImplementedError)
-    end
-  end
-end

data/spec/stoplight/data_store/base_spec.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::DataStore::Base do
-  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
-
-  describe '#with_notification_lock' do
-    it 'is not implemented' do
-      expect { data_store.with_notification_lock(nil, nil, nil) }
-        .to raise_error(NotImplementedError)
-    end
-  end
-end

data/spec/stoplight/data_store/memory_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::DataStore::Memory do
-  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) }
-  let(:other) { Stoplight::Failure.new('class', 'message 2', Time.new) }
-
-  it_behaves_like 'Stoplight::DataStore::Base'
-  it_behaves_like 'Stoplight::DataStore::Base#names'
-  it_behaves_like 'Stoplight::DataStore::Base#get_failures'
-  it_behaves_like 'Stoplight::DataStore::Base#get_all'
-  it_behaves_like 'Stoplight::DataStore::Base#record_failure'
-  it_behaves_like 'Stoplight::DataStore::Base#clear_failures'
-  it_behaves_like 'Stoplight::DataStore::Base#get_state'
-  it_behaves_like 'Stoplight::DataStore::Base#set_state'
-  it_behaves_like 'Stoplight::DataStore::Base#clear_state'
-  it_behaves_like 'Stoplight::DataStore::Base#with_notification_lock'
-end

data/spec/stoplight/data_store/redis_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::DataStore::Redis, :redis do
-  let(:data_store) { described_class.new(redis, redlock: redlock) }
-  let(:redlock) { instance_double(Redlock::Client) }
-  let(:light) { Stoplight::Light.new(name) {} }
-  let(:name) { ('a'..'z').to_a.shuffle.join }
-  let(:failure) { Stoplight::Failure.new('class', 'message', Time.new - 60) }
-  let(:other) { Stoplight::Failure.new('class', 'message 2', Time.new) }
-
-  it_behaves_like 'Stoplight::DataStore::Base'
-  it_behaves_like 'Stoplight::DataStore::Base#names'
-  it_behaves_like 'Stoplight::DataStore::Base#get_all'
-  it_behaves_like 'Stoplight::DataStore::Base#record_failure'
-  it_behaves_like 'Stoplight::DataStore::Base#clear_failures'
-  it_behaves_like 'Stoplight::DataStore::Base#get_state'
-  it_behaves_like 'Stoplight::DataStore::Base#set_state'
-  it_behaves_like 'Stoplight::DataStore::Base#clear_state'
-
-  it_behaves_like 'Stoplight::DataStore::Base#get_failures' do
-    context 'when JSON is invalid' do
-      before do
-        light.with_error_notifier { |_error| }
-      end
-
-      it 'handles it without an error' do
-        expect(failure).to receive(:to_json).and_return('invalid JSON')
-
-        expect { data_store.record_failure(light, failure) }
-          .to change { data_store.get_failures(light) }
-          .to([have_attributes(error_class: 'JSON::ParserError')])
-      end
-    end
-  end
-
-  it_behaves_like 'Stoplight::DataStore::Base#with_notification_lock' do
-    let(:lock_key) { "stoplight:v4:notification_lock:#{name}" }
-
-    before do
-      allow(redlock).to receive(:lock).with(lock_key, 2_000).and_yield
-    end
-  end
-end

data/spec/stoplight/data_store_spec.rb

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

data/spec/stoplight/default_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::Default do
-  it 'is a module' do
-    expect(described_class).to be_a(Module)
-  end
-
-  describe '::COOL_OFF_TIME' do
-    it 'is a float' do
-      expect(Stoplight::Default::COOL_OFF_TIME).to be_a(Float)
-    end
-  end
-
-  describe '::DATA_STORE' do
-    it 'is a data store' do
-      expect(Stoplight::Default::DATA_STORE).to be_a(Stoplight::DataStore::Base)
-    end
-  end
-
-  describe '::ERROR_HANDLER' do
-    it 'is a proc' do
-      expect(Stoplight::Default::ERROR_HANDLER).to be_a(Proc)
-    end
-
-    it 'has an arity of 2' do
-      expect(Stoplight::Default::ERROR_HANDLER.arity).to eql(2)
-    end
-  end
-
-  describe '::ERROR_NOTIFIER' do
-    it 'is a proc' do
-      expect(Stoplight::Default::ERROR_NOTIFIER).to be_a(Proc)
-    end
-
-    it 'has an arity of 1' do
-      expect(Stoplight::Default::ERROR_NOTIFIER.arity).to eql(1)
-    end
-  end
-
-  describe '::FALLBACK' do
-    it 'is nil' do
-      expect(Stoplight::Default::FALLBACK).to eql(nil)
-    end
-  end
-
-  describe '::FORMATTER' do
-    it 'is a proc' do
-      expect(Stoplight::Default::FORMATTER).to be_a(Proc)
-    end
-
-    it 'has the same arity as #notify' do
-      notify = Stoplight::Notifier::Base.new.method(:notify)
-      expect(Stoplight::Default::FORMATTER.arity).to eql(notify.arity)
-    end
-  end
-
-  describe '::NOTIFIERS' do
-    it 'is an array' do
-      expect(Stoplight::Default::NOTIFIERS).to be_an(Array)
-    end
-
-    it 'contains notifiers' do
-      Stoplight::Default::NOTIFIERS.each do |notifier|
-        expect(notifier).to be_a(Stoplight::Notifier::Base)
-      end
-    end
-
-    it 'is frozen' do
-      expect(Stoplight::Default::NOTIFIERS).to be_frozen
-    end
-  end
-
-  describe '::THRESHOLD' do
-    it 'is an integer' do
-      expect(Stoplight::Default::THRESHOLD).to be_a(Integer)
-    end
-  end
-end

data/spec/stoplight/error_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::Error do
-  it 'is a module' do
-    expect(described_class).to be_a(Module)
-  end
-
-  describe '::Base' do
-    it 'is a class' do
-      expect(Stoplight::Error::Base).to be_a(Class)
-    end
-
-    it 'is a subclass of StandardError' do
-      expect(Stoplight::Error::Base).to be < StandardError
-    end
-  end
-
-  describe '::IncorrectColor' do
-    it 'is a class' do
-      expect(Stoplight::Error::IncorrectColor).to be_a(Class)
-    end
-
-    it 'is a subclass of StandardError' do
-      expect(Stoplight::Error::IncorrectColor).to be < StandardError
-    end
-  end
-
-  describe '::RedLight' do
-    it 'is a class' do
-      expect(Stoplight::Error::RedLight).to be_a(Class)
-    end
-
-    it 'is a subclass of StandardError' do
-      expect(Stoplight::Error::RedLight).to be < Stoplight::Error::Base
-    end
-  end
-end

data/spec/stoplight/failure_spec.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::Failure do
-  let(:error) { ZeroDivisionError.new('divided by 0') }
-  let(:error_class) { error.class.name }
-  let(:error_message) { error.message }
-  let(:time) { Time.new(2001, 2, 3, 4, 5, 6, '+07:08') }
-  let(:json) do
-    JSON.generate(
-      error: { class: error_class, message: error_message },
-      time: time.strftime('%Y-%m-%dT%H:%M:%S.%N%:z')
-    )
-  end
-
-  it 'is a class' do
-    expect(described_class).to be_a(Class)
-  end
-
-  describe '.from_error' do
-    it 'creates a failure' do
-      Timecop.freeze do
-        failure = described_class.from_error(error)
-        expect(failure.error_class).to eql(error_class)
-        expect(failure.error_message).to eql(error_message)
-        expect(failure.time).to eql(Time.new)
-      end
-    end
-  end
-
-  describe '.from_json' do
-    it 'parses JSON' do
-      failure = described_class.from_json(json)
-      expect(failure.error_class).to eql(error_class)
-      expect(failure.error_message).to eql(error_message)
-      expect(failure.time).to eql(time)
-    end
-  end
-
-  describe '#==' do
-    it 'is true when they are equal' do
-      failure = described_class.new(error_class, error_message, time)
-      other = described_class.new(error_class, error_message, time)
-      expect(failure).to eq(other)
-    end
-
-    it 'is false when they have different error classes' do
-      failure = described_class.new(error_class, error_message, time)
-      other = described_class.new(nil, error_message, time)
-      expect(failure).to_not eq(other)
-    end
-
-    it 'is false when they have different error messages' do
-      failure = described_class.new(error_class, error_message, time)
-      other = described_class.new(error_class, nil, time)
-      expect(failure).to_not eq(other)
-    end
-
-    it 'is false when they have different times' do
-      failure = described_class.new(error_class, error_message, time)
-      other = described_class.new(error_class, error_message, nil)
-      expect(failure).to_not eq(other)
-    end
-  end
-
-  describe '#error_class' do
-    it 'reads the error class' do
-      expect(described_class.new(error_class, nil, nil).error_class)
-        .to eql(error_class)
-    end
-  end
-
-  describe '#error_message' do
-    it 'reads the error message' do
-      expect(described_class.new(nil, error_message, nil).error_message)
-        .to eql(error_message)
-    end
-  end
-
-  describe '#time' do
-    it 'reads the time' do
-      expect(described_class.new(nil, nil, time).time).to eql(time)
-    end
-  end
-
-  describe '#to_json' do
-    it 'generates JSON' do
-      expect(described_class.new(error_class, error_message, time).to_json)
-        .to eql(json)
-    end
-
-    it 'generates JSON with options' do
-      expect(described_class.new(error_class, error_message, time).to_json({}))
-        .to eql(json)
-    end
-  end
-
-  describe '::TIME_FORMAT' do
-    it 'is a string' do
-      expect(described_class::TIME_FORMAT).to be_a(String)
-    end
-
-    it 'is frozen' do
-      expect(described_class::TIME_FORMAT).to be_frozen
-    end
-  end
-end

data/spec/stoplight/light/lockable_spec.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Stoplight::Light::Lockable do
-  subject(:light) { Stoplight::Light.new(name, &code) }
-
-  let(:code) { -> { code_result } }
-  let(:code_result) { random_string }
-  let(:name) { random_string }
-
-  def random_string
-    ('a'..'z').to_a.sample(8).join
-  end
-
-  describe '#lock' do
-    let(:color) { Stoplight::Color::GREEN }
-
-    context 'with correct color' do
-      it 'returns the light' do
-        expect(light.lock(color)).to be_a Stoplight::Light
-      end
-
-      context 'with green color' do
-        let(:color) { Stoplight::Color::GREEN }
-
-        it 'locks green color' do
-          expect(light.data_store).to receive(:set_state).with(light, Stoplight::State::LOCKED_GREEN)
-
-          light.lock(color)
-        end
-      end
-
-      context 'with red color' do
-        let(:color) { Stoplight::Color::RED }
-
-        it 'locks red color' do
-          expect(light.data_store).to receive(:set_state).with(light, Stoplight::State::LOCKED_RED)
-
-          light.lock(color)
-        end
-      end
-    end
-
-    context 'with incorrect color' do
-      let(:color) { 'incorrect-color' }
-
-      it 'raises Error::IncorrectColor error' do
-        expect { light.lock(color) }.to raise_error(Stoplight::Error::IncorrectColor)
-      end
-
-      it 'does not lock color' do
-        expect(light.data_store).to_not receive(:set_state)
-
-        suppress(Stoplight::Error::IncorrectColor) { light.lock(color) }
-      end
-    end
-  end
-
-  describe '#unlock' do
-    it 'returns the light' do
-      expect(light.unlock).to be_a Stoplight::Light
-    end
-
-    context 'with locked green light' do
-      before { light.lock(Stoplight::Color::GREEN) }
-
-      it 'unlocks light' do
-        expect(light.data_store).to receive(:set_state).with(light, Stoplight::State::UNLOCKED)
-
-        light.unlock
-      end
-    end
-
-    context 'with locked red light' do
-      before { light.lock(Stoplight::Color::RED) }
-
-      it 'unlocks light' do
-        expect(light.data_store).to receive(:set_state).with(light, Stoplight::State::UNLOCKED)
-
-        light.unlock
-      end
-    end
-
-    context 'with unlocked light' do
-      it 'unlocks light' do
-        expect(light.data_store).to receive(:set_state).with(light, Stoplight::State::UNLOCKED)
-
-        light.unlock
-      end
-    end
-  end
-end

data/spec/stoplight/light/runnable_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'stringio'
-
-RSpec.describe Stoplight::Light::Runnable, :redis do
-  let(:failure) do
-    Stoplight::Failure.new(error.class.name, error.message, time)
-  end
-  let(:error) { error_class.new(error_message) }
-  let(:error_class) { Class.new(StandardError) }
-  let(:error_message) { random_string }
-  let(:time) { Time.new }
-
-  def random_string
-    ('a'..'z').to_a.sample(8).join
-  end
-
-  before do
-    light.with_data_store(data_store)
-  end
-
-  context 'with memory data store' do
-    let(:data_store) { Stoplight::DataStore::Memory.new }
-
-    it_behaves_like 'Stoplight::Light::Runnable#state'
-    it_behaves_like 'Stoplight::Light::Runnable#color'
-    it_behaves_like 'Stoplight::Light::Runnable#run'
-  end
-
-  context 'with redis data store', :redis do
-    let(:data_store) { Stoplight::DataStore::Redis.new(redis) }
-
-    it_behaves_like 'Stoplight::Light::Runnable#state'
-    it_behaves_like 'Stoplight::Light::Runnable#color'
-    it_behaves_like 'Stoplight::Light::Runnable#run'
-  end
-end