stoplight 3.0.0 → 4.0.0

data/lib/stoplight/notifier/hip_chat.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Notifier
-    # @see Base
-    class HipChat < Base
-      DEFAULT_OPTIONS = {
-        color: 'purple',
-        message_format: 'text',
-        notify: true
-      }.freeze
-
-      # @return [Proc]
-      attr_reader :formatter
-      # @return [::HipChat::Client]
-      attr_reader :hip_chat
-      # @return [Hash{Symbol => Object}]
-      attr_reader :options
-      # @return [String]
-      attr_reader :room
-
-      # @param hip_chat [::HipChat::Client]
-      # @param room [String]
-      # @param formatter [Proc, nil]
-      # @param options [Hash{Symbol => Object}]
-      # @option options [String] :color
-      # @option options [String] :message_format
-      # @option options [Boolean] :notify
-      def initialize(hip_chat, room, formatter = nil, options = {})
-        @hip_chat = hip_chat
-        @room = room
-        @formatter = formatter || Default::FORMATTER
-        @options = DEFAULT_OPTIONS.merge(options)
-      end
-
-      def notify(light, from_color, to_color, error)
-        message = formatter.call(light, from_color, to_color, error)
-        hip_chat[room].send('Stoplight', message, options)
-        message
-      end
-    end
-  end
-end

data/lib/stoplight/notifier/honeybadger.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Notifier
-    # @see Base
-    class Honeybadger < Base
-      DEFAULT_OPTIONS = {
-        parameters: {},
-        session: {},
-        context: {}
-      }.freeze
-
-      # @return [String]
-      attr_reader :api_key
-      # @return [Proc]
-      attr_reader :formatter
-      # @return [Hash{Symbol => Object}]
-      attr_reader :options
-
-      # @param api_key [String]
-      # @param formatter [Proc, nil]
-      # @param options [Hash{Symbol => Object}]
-      # @option options [Hash] :parameters
-      # @option options [Hash] :session
-      # @option options [Hash] :context
-      def initialize(api_key, formatter = nil, options = {})
-        @api_key = api_key
-        @formatter = formatter || Default::FORMATTER
-        @options = DEFAULT_OPTIONS.merge(options)
-      end
-
-      def notify(light, from_color, to_color, error)
-        message = formatter.call(light, from_color, to_color, error)
-        h = options.merge(
-          api_key: api_key,
-          error_message: message,
-          backtrace: error&.backtrace
-        )
-        ::Honeybadger.notify(h)
-        message
-      end
-    end
-  end
-end

data/lib/stoplight/notifier/pagerduty.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Notifier
-    # @see Base
-    class Pagerduty < Base
-      include Generic
-
-      # @return [::Pagerduty]
-      def pagerduty
-        @object
-      end
-
-      private
-
-      def put(message)
-        pagerduty.trigger(message)
-      end
-    end
-  end
-end

data/lib/stoplight/notifier/raven.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Notifier
-    # @see Base
-    class Raven < Base
-      DEFAULT_OPTIONS = {
-        extra: {}
-      }.freeze
-
-      # @return [::Raven::Configuration]
-      attr_reader :configuration
-      # @return [Proc]
-      attr_reader :formatter
-      # @return [Hash{Symbol => Object}]
-      attr_reader :options
-
-      # @param api_key [String]
-      # @param formatter [Proc, nil]
-      # @param options [Hash{Symbol => Object}]
-      # @option options [Hash] :extra
-      def initialize(configuration, formatter = nil, options = {})
-        @configuration = configuration
-        @formatter = formatter || Default::FORMATTER
-        @options = DEFAULT_OPTIONS.merge(options)
-      end
-
-      def notify(light, from_color, to_color, error)
-        message = formatter.call(light, from_color, to_color, error)
-
-        h = options.merge(
-          configuration: configuration,
-          backtrace: error&.backtrace
-        )
-        ::Raven.capture_message(message, h)
-        message
-      end
-    end
-  end
-end

data/lib/stoplight/notifier/rollbar.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Notifier
-    # @see Base
-    class Rollbar < Base
-      DEFAULT_OPTIONS = {
-        severity: 'info'
-      }.freeze
-
-      StoplightStatusChange = Class.new(Error::Base)
-
-      # @return [Proc]
-      attr_reader :formatter
-      # @return [::Rollbar]
-      attr_reader :rollbar
-      # @return [Hash{Symbol => Object}]
-      attr_reader :options
-
-      # @param rollbar [::Rollbar]
-      # @param formatter [Proc, nil]
-      # @param options [Hash{Symbol => Object}]
-      # @option options [String] :severity
-      def initialize(rollbar, formatter = nil, options = {})
-        @rollbar = rollbar
-        @formatter = formatter || Default::FORMATTER
-        @options = DEFAULT_OPTIONS.merge(options)
-      end
-
-      def notify(light, from_color, to_color, error)
-        formatter.call(light, from_color, to_color, error).tap do |message|
-          severity = options.fetch(:severity)
-          exception = StoplightStatusChange.new(message)
-          rollbar.__send__(severity, exception)
-        end
-      end
-    end
-  end
-end

data/lib/stoplight/notifier/slack.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Stoplight
-  module Notifier
-    # @see Base
-    class Slack < Base
-      include Generic
-
-      # @return [::Slack::Notifier]
-      def slack
-        @object
-      end
-
-      private
-
-      def put(message)
-        slack.ping(message)
-      end
-    end
-  end
-end

data/spec/stoplight/notifier/bugsnag_spec.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-# require 'bugsnag'
-module Bugsnag
-end
-
-RSpec.describe Stoplight::Notifier::Bugsnag 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::Bugsnag::DEFAULT_OPTIONS)
-    end
-
-    it 'reads the options' do
-      options = { key: :value }
-      expect(described_class.new(nil, nil, options).options)
-        .to eql(Stoplight::Notifier::Bugsnag::DEFAULT_OPTIONS.merge(options))
-    end
-  end
-
-  describe '#bugsnag' do
-    it 'reads the Bugsnag client' do
-      client = Bugsnag
-      expect(described_class.new(client, nil).bugsnag)
-        .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(bugsnag) }
-    let(:bugsnag) { Bugsnag }
-
-    subject(:result) do
-      notifier.notify(light, from_color, to_color, error)
-    end
-
-    before do
-      status_change = described_class::StoplightStatusChange.new(message)
-      expect(bugsnag).to receive(:notify).with(status_change, severity: 'info')
-    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/hip_chat_spec.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-# require 'hipchat'
-module HipChat
-  class Client
-    def initialize(*); end
-  end
-end
-
-RSpec.describe Stoplight::Notifier::HipChat 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, nil, formatter).formatter)
-        .to eql(formatter)
-    end
-  end
-
-  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
-
-  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 '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
-
-  describe '#room' do
-    it 'reads the room' do
-      room = 'Notifications'
-      expect(described_class.new(nil, room).room).to eql(room)
-    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(hip_chat, room) }
-    let(:hip_chat) { double(HipChat::Client) }
-    let(:room) { ('a'..'z').to_a.shuffle.join }
-
-    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 '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 '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

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