stoplight 3.0.2 → 4.0.0

data/spec/stoplight/notifier/honeybadger_spec.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-# require 'honeybadger'
-module Honeybadger
-end
-
-RSpec.describe Stoplight::Notifier::Honeybadger do
-  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).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 '#options' do
-    it 'is initially the default' do
-      expect(described_class.new(nil).options).to eql(
-        Stoplight::Notifier::Honeybadger::DEFAULT_OPTIONS
-      )
-    end
-
-    it 'reads the options' do
-      options = { key: :value }
-      expect(described_class.new(nil, nil, options).options).to eql(
-        Stoplight::Notifier::Honeybadger::DEFAULT_OPTIONS.merge(options)
-      )
-    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(api_key) }
-    let(:api_key) { ('a'..'z').to_a.shuffle.join }
-
-    before do
-      allow(Honeybadger).to receive(:notify)
-    end
-
-    it 'returns the message' do
-      error = nil
-      message = notifier.formatter.call(light, from_color, to_color, error)
-      expect(notifier.notify(light, from_color, to_color, error)).to eql(
-        message
-      )
-      expect(Honeybadger).to have_received(:notify).with(
-        hash_including(
-          api_key: api_key,
-          error_message: message
-        )
-      )
-    end
-
-    it 'returns the message with an error' do
-      error = ZeroDivisionError.new('divided by 0')
-      message = notifier.formatter.call(light, from_color, to_color, error)
-      expect(notifier.notify(light, from_color, to_color, error)).to eql(
-        message
-      )
-      expect(Honeybadger).to have_received(:notify).with(
-        hash_including(
-          api_key: api_key,
-          error_message: message,
-          backtrace: error.backtrace
-        )
-      )
-    end
-  end
-end

data/spec/stoplight/notifier/pagerduty_spec.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'pagerduty'
-
-RSpec.describe Stoplight::Notifier::Pagerduty 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 '#pagerduty' do
-    it 'reads Pagerduty client' do
-      pagerduty = Pagerduty.new('WEBHOOK_URL')
-      expect(described_class.new(pagerduty).pagerduty).to eql(pagerduty)
-    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(pagerduty) }
-    let(:pagerduty) { double(Pagerduty).as_null_object }
-
-    it 'pings Pagerduty' do
-      error = nil
-      message = notifier.formatter.call(light, from_color, to_color, error)
-      expect(pagerduty).to receive(:trigger).with(message)
-      notifier.notify(light, from_color, to_color, error)
-    end
-  end
-end

data/spec/stoplight/notifier/raven_spec.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-# require 'sentry-raven'
-module Raven
-  class Configuration
-  end
-end
-
-RSpec.describe Stoplight::Notifier::Raven do
-  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).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 '#options' do
-    it 'is initially the default' do
-      expect(described_class.new(nil).options).to eql(
-        Stoplight::Notifier::Raven::DEFAULT_OPTIONS
-      )
-    end
-
-    it 'reads the options' do
-      options = { key: :value }
-      expect(described_class.new(nil, nil, options).options).to eql(
-        Stoplight::Notifier::Raven::DEFAULT_OPTIONS.merge(options)
-      )
-    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(configuration) }
-    let(:configuration) { instance_double(::Raven::Configuration) }
-
-    before do
-      allow(::Raven).to receive(:capture_message)
-    end
-
-    it 'returns the message' do
-      error = nil
-      message = notifier.formatter.call(light, from_color, to_color, error)
-      expect(notifier.notify(light, from_color, to_color, error)).to eql(
-        message
-      )
-      expect(::Raven).to have_received(:capture_message).with(
-        message,
-        hash_including(
-          configuration: configuration
-        )
-      )
-    end
-
-    it 'returns the message with an error' do
-      error = ZeroDivisionError.new('divided by 0')
-      message = notifier.formatter.call(light, from_color, to_color, error)
-      expect(notifier.notify(light, from_color, to_color, error)).to eql(
-        message
-      )
-      expect(::Raven).to have_received(:capture_message).with(
-        message,
-        hash_including(
-          configuration: configuration,
-          backtrace: error.backtrace
-        )
-      )
-    end
-  end
-end

data/spec/stoplight/notifier/rollbar_spec.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-# require 'rollbar'
-module Rollbar
-end
-
-RSpec.describe Stoplight::Notifier::Rollbar do
-  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 '#options' do
-    it 'is initially the default' do
-      expect(described_class.new(nil, nil).options)
-        .to eql(Stoplight::Notifier::Rollbar::DEFAULT_OPTIONS)
-    end
-
-    it 'reads the options' do
-      options = { key: :value }
-      expect(described_class.new(nil, nil, options).options)
-        .to eql(Stoplight::Notifier::Rollbar::DEFAULT_OPTIONS.merge(options))
-    end
-  end
-
-  describe '#rollbar' do
-    it 'reads the Rollbar client' do
-      client = Rollbar
-      expect(described_class.new(client, nil).rollbar)
-        .to eql(client)
-    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(rollbar) }
-    let(:rollbar) { Rollbar }
-
-    subject(:result) do
-      notifier.notify(light, from_color, to_color, error)
-    end
-
-    before do
-      status_change = described_class::StoplightStatusChange.new(message)
-      expect(rollbar).to receive(:info).with(status_change)
-    end
-
-    context 'when no error given' do
-      let(:error) { nil }
-
-      it 'logs message' do
-        expect(result).to eq(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 eq(message)
-      end
-    end
-
-    def message
-      notifier.formatter.call(light, from_color, to_color, error)
-    end
-  end
-end

data/spec/stoplight/notifier/slack_spec.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-# require 'slack-notifier'
-module Slack
-  class Notifier
-    def initialize(*); end
-  end
-end
-
-RSpec.describe Stoplight::Notifier::Slack 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 '#slack' do
-    it 'reads Slack::Notifier client' do
-      slack = Slack::Notifier.new('WEBHOOK_URL')
-      expect(described_class.new(slack).slack).to eql(slack)
-    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(slack) }
-    let(:slack) { double(Slack::Notifier).as_null_object }
-
-    it 'pings Slack' do
-      error = nil
-      message = notifier.formatter.call(light, from_color, to_color, error)
-      expect(slack).to receive(:ping).with(message)
-      notifier.notify(light, from_color, to_color, error)
-    end
-  end
-end