slack-notifier 1.5.1 → 2.0.0

data/lib/slack-notifier/version.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
 module Slack
   class Notifier
-    VERSION = "1.5.1"
+    VERSION = "2.0.0".freeze # rubocop:disable Style/RedundantFreeze
   end
 end

data/spec/end_to_end_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+# encoding: utf-8
+require "spec_helper"
+
+RSpec.describe Slack::Notifier do
+  {
+    { text: "hello" } =>
+    { payload: { text: "hello" } },
+
+    { text: "[hello](http://example.com/world)" } =>
+    { payload: { text: "<http://example.com/world|hello>" } },
+
+    { text: '<a href="http://example.com">example</a>' } =>
+    { payload: { text: "<http://example.com|example>" } },
+
+    { text: "hello/こんにちは from notifier test" } =>
+    { payload: { text: "hello/こんにちは from notifier test" } },
+
+    { text: "Hello World, enjoy [](http://example.com)." } =>
+    { payload: { text: "Hello World, enjoy <http://example.com>." } },
+
+    { text: "Hello World, enjoy [this](http://example.com)[this2](http://example2.com)" } =>
+    { payload: { text: "Hello World, enjoy <http://example.com|this><http://example2.com|this2>" } },
+
+    { text: "[John](mailto:john@example.com)" } =>
+    { payload: { text: "<mailto:john@example.com|John>" } },
+
+    { text: '<a href="mailto:john@example.com">John</a>' } =>
+    { payload: { text: "<mailto:john@example.com|John>" } },
+
+    { text: "hello", channel: "hodor" } =>
+    { payload: { text: "hello", channel: "hodor" } },
+
+    { text: "the message", channel: "foo", attachments: [{ color: "#000",
+                                                           text: "attachment message",
+                                                           fallback: "fallback message" }] } =>
+    { payload: { text: "the message",
+                 channel: "foo",
+                 attachments: [{ color: "#000",
+                                 text: "attachment message",
+                                 fallback: "fallback message" }] } },
+
+    { attachments: [{ color: "#000",
+                      text: "attachment message",
+                      fallback: "fallback message" }] } =>
+    { payload: { attachments: [{ color: "#000",
+                                 text: "attachment message",
+                                 fallback: "fallback message" }] } },
+
+    { attachments: { color: "#000",
+                     text: "attachment message [hodor](http://winterfell.com)",
+                     fallback: "fallback message" } } =>
+    { payload: { attachments: { color: "#000",
+                                text: "attachment message <http://winterfell.com|hodor>",
+                                fallback: "fallback message" } } },
+
+    { text: "hello", http_options: { timeout: 5 } } =>
+    { http_options: { timeout: 5 }, payload: { text: "hello" } }
+  }.each do |args, payload|
+    it "sends correct payload for #post(#{args})" do
+      http_client       = class_double("Slack::Notifier::Util::HTTPClient", post: nil)
+      notifier          = Slack::Notifier.new "http://example.com", http_client: http_client
+      payload[:payload] = payload[:payload].to_json
+
+      expect(http_client).to receive(:post)
+        .with(URI.parse("http://example.com"), payload)
+
+      notifier.post(args)
+    end
+  end
+
+  it "applies options given to middleware" do
+    client   = class_double("Slack::Notifier::Util::HTTPClient", post: nil)
+    notifier = Slack::Notifier.new "http://example.com" do
+      http_client client
+      middleware format_message: { formats: [] }
+    end
+
+    expect(client).to receive(:post)
+      .with(URI.parse("http://example.com"), payload: { text: "Hello [world](http://example.com)!" }.to_json)
+
+    notifier.post text: "Hello [world](http://example.com)!"
+  end
+end

data/spec/integration/ping_integration_test.rb

@@ -1,7 +1,14 @@
+# frozen_string_literal: true
 # encoding: utf-8
-require_relative '../../lib/slack-notifier'
+require_relative "../../lib/slack-notifier"
 
-notifier = Slack::Notifier.new ENV['SLACK_WEBHOOK_URL'], username: 'notifier'
-puts "testing with ruby #{RUBY_VERSION}"
-notifier.ping "hello/こんにちは from notifier test script on ruby: #{RUBY_VERSION}\225"
-notifier.ping attachments: [{color:"#1BF5AF",fallback:"fallback",text:"attachment"}]
+ruby = if defined?(JRUBY_VERSION)
+  "jruby #{JRUBY_VERSION}"
+else
+  "ruby #{RUBY_VERSION}"
+end
+puts "testing with #{ruby}"
+
+notifier = Slack::Notifier.new ENV["SLACK_WEBHOOK_URL"], username: "notifier"
+notifier.ping "hello/こんにちは from notifier test script on #{ruby}\225"
+notifier.ping attachments: [{ color: "#1BF5AF", fallback: "fallback", text: "attachment" }]

data/spec/lib/slack-notifier/config_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Notifier::Config do
+  describe "#http_client" do
+    it "is Util::HTTPClient if not set" do
+      subject = described_class.new
+      expect(subject.http_client).to eq Slack::Notifier::Util::HTTPClient
+    end
+
+    it "sets a new client class if given one" do
+      new_client = class_double("Slack::Notifier::Util::HTTPClient", post: nil)
+      subject    = described_class.new
+      subject.http_client new_client
+      expect(subject.http_client).to eq new_client
+    end
+
+    it "raises an ArgumentError if given class does not respond to ::post" do
+      subject = described_class.new
+      expect do
+        subject.http_client :nope
+      end.to raise_error ArgumentError
+    end
+  end
+
+  describe "#defaults" do
+    it "is an empty hash by default" do
+      subject = described_class.new
+      expect(subject.defaults).to eq({})
+    end
+
+    it "sets a hash to default if given" do
+      subject = described_class.new
+      subject.defaults foo: :bar
+      expect(subject.defaults).to eq foo: :bar
+    end
+
+    it "raises ArgumentError if not given a hash" do
+      subject = described_class.new
+      expect do
+        subject.defaults :nope
+      end.to raise_error ArgumentError
+    end
+  end
+
+  describe "#middleware" do
+    it "is [:format_message, :format_attachments] if not set" do
+      subject = described_class.new
+
+      expect(subject.middleware).to eq [:format_message, :format_attachments]
+    end
+
+    it "takes an array or a splat of args" do
+      subject = described_class.new
+
+      subject.middleware :layer, :two
+      expect(subject.middleware).to eq [:layer, :two]
+
+      subject.middleware [:one, :layer]
+      expect(subject.middleware).to eq [:one, :layer]
+    end
+
+    it "allows passing options to middleware stack" do
+      subject = described_class.new
+      subject.middleware one: { opts: :for_one },
+                         two: { opts: :for_two }
+
+      expect(subject.middleware).to eq one: { opts: :for_one },
+                                       two: { opts: :for_two }
+    end
+  end
+end

data/spec/lib/slack-notifier/payload_middleware/base_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+RSpec.describe Slack::Notifier::PayloadMiddleware::Base do
+  before(:each) do
+    @registry_backup = Slack::Notifier::PayloadMiddleware.registry.dup
+    Slack::Notifier::PayloadMiddleware.send(:remove_instance_variable, :@registry)
+  end
+
+  after(:each) do
+    # cleanup middleware registry
+    Slack::Notifier::PayloadMiddleware.registry
+    Slack::Notifier::PayloadMiddleware.send(:remove_instance_variable, :@registry)
+
+    # cleanup object constants
+    Object.send(:remove_const, :Subject) if Object.constants.include?(:Subject)
+    Slack::Notifier::PayloadMiddleware.send(:instance_variable_set, :@registry, @registry_backup)
+  end
+
+  describe "::middleware_name" do
+    it "registers class w/ given name" do
+      class Subject < Slack::Notifier::PayloadMiddleware::Base
+      end
+
+      expect(Slack::Notifier::PayloadMiddleware)
+        .to receive(:register).with(Subject, :subject)
+
+      class Subject
+        middleware_name :subject
+      end
+    end
+
+    it "uses symbolized name to register" do
+      class Subject < Slack::Notifier::PayloadMiddleware::Base
+      end
+
+      expect(Slack::Notifier::PayloadMiddleware)
+        .to receive(:register).with(Subject, :subject)
+
+      class Subject
+        middleware_name "subject"
+      end
+    end
+  end
+
+  describe "::options" do
+    it "allows setting default options for a middleware" do
+      class Subject < Slack::Notifier::PayloadMiddleware::Base
+        options foo: :bar
+      end
+
+      subject = Subject.new(:notifier)
+      expect(subject.options).to eq foo: :bar
+
+      subject = Subject.new(:notifier, foo: :baz)
+      expect(subject.options).to eq foo: :baz
+    end
+  end
+
+  describe "#initialize" do
+    it "sets given notifier as notifier" do
+      expect(described_class.new(:notifier).notifier).to eq :notifier
+    end
+
+    it "sets given options as opts" do
+      expect(described_class.new(:notifier, opts: :options).options).to eq opts: :options
+    end
+  end
+
+  describe "#call" do
+    it "raises NoMethodError (expects subclass to define)" do
+      expect do
+        described_class.new(:notifier).call
+      end.to raise_exception NoMethodError
+    end
+  end
+end

data/spec/lib/slack-notifier/payload_middleware/format_attachments_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+RSpec.describe Slack::Notifier::PayloadMiddleware::FormatAttachments do
+  it "passes the text of attachments through linkformatter with options[:formats]" do
+    subject = described_class.new(:notifier, formats: [:html])
+    expect(Slack::Notifier::Util::LinkFormatter).to receive(:format)
+      .with("hello", formats: [:html])
+    subject.call(attachments: [{ text: "hello" }])
+  end
+
+  it "searches through string or symbol keys" do
+    subject = described_class.new(:notifier)
+    expect(Slack::Notifier::Util::LinkFormatter).to receive(:format)
+      .with("hello", formats: [:html, :markdown])
+    subject.call("attachments" => [{ "text" => "hello" }])
+
+    subject = described_class.new(:notifier)
+    expect(Slack::Notifier::Util::LinkFormatter).to receive(:format)
+      .with("hello", formats: [:html, :markdown])
+    subject.call(attachments: [{ text: "hello" }])
+  end
+
+  it "can handle a single attachment" do
+    subject = described_class.new(:notifier)
+    expect(Slack::Notifier::Util::LinkFormatter).to receive(:format)
+      .with("hello", formats: [:html, :markdown])
+    subject.call(attachments: { text: "hello" })
+  end
+
+  it "returns the payload unmodified if not :attachments key" do
+    payload = { foo: :bar }
+    subject = described_class.new(:notifier)
+
+    expect(subject.call(payload)).to eq payload
+  end
+end

data/spec/lib/slack-notifier/payload_middleware/format_message_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+RSpec.describe Slack::Notifier::PayloadMiddleware::FormatMessage do
+  it "passes the text through linkformatter with options[:formats]" do
+    subject = described_class.new(:notifier, formats: [:html])
+    expect(Slack::Notifier::Util::LinkFormatter).to receive(:format)
+      .with("hello", formats: [:html])
+    subject.call(text: "hello")
+
+    subject = described_class.new(:notifier)
+    expect(Slack::Notifier::Util::LinkFormatter).to receive(:format)
+      .with("hello", formats: [:html, :markdown])
+    subject.call(text: "hello")
+
+    subject = described_class.new(:notifier, formats: [:markdown])
+    expect(Slack::Notifier::Util::LinkFormatter).to receive(:format)
+      .with("hello", formats: [:markdown])
+    subject.call(text: "hello")
+  end
+
+  it "returns the payload unmodified if not :text key" do
+    payload = { foo: :bar }
+    subject = described_class.new(:notifier)
+
+    expect(subject.call(payload)).to eq payload
+  end
+end

data/spec/lib/slack-notifier/payload_middleware/stack_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+RSpec.describe Slack::Notifier::PayloadMiddleware::Stack do
+  let(:return_one) do
+    double(call: 1)
+  end
+
+  let(:return_two) do
+    double(call: 2)
+  end
+
+  let(:return_three) do
+    double(call: 3)
+  end
+
+  before(:each) do
+    # setup our middleware in the registry
+    @registry_backup = Slack::Notifier::PayloadMiddleware.registry.dup
+    Slack::Notifier::PayloadMiddleware.send(:remove_instance_variable, :@registry)
+
+    Slack::Notifier::PayloadMiddleware.register return_one, :return_one
+    Slack::Notifier::PayloadMiddleware.register return_two, :return_two
+    Slack::Notifier::PayloadMiddleware.register return_three, :return_three
+  end
+
+  after(:each) do
+    # cleanup middleware registry
+    Slack::Notifier::PayloadMiddleware.send(:remove_instance_variable, :@registry)
+    Slack::Notifier::PayloadMiddleware.send(:instance_variable_set, :@registry, @registry_backup)
+  end
+
+  describe "::initialize" do
+    it "sets notifier to given notifier" do
+      expect(described_class.new(:notifier).notifier).to eq :notifier
+    end
+
+    it "has empty stack" do
+      expect(described_class.new(:notifier).stack).to match_array []
+    end
+  end
+
+  describe "#set" do
+    it "initializes each middleware w/ the notifier instance" do
+      expect(return_one).to receive(:new).with(:notifier)
+      expect(return_two).to receive(:new).with(:notifier)
+
+      described_class.new(:notifier).set(:return_one, :return_two)
+    end
+
+    it "creates the stack in an array" do
+      allow(return_one).to receive(:new).and_return(return_one)
+      allow(return_two).to receive(:new).and_return(return_two)
+
+      subject = described_class.new(:notifier)
+      subject.set(:return_one, :return_two)
+
+      expect(subject.stack).to be_a Array
+      expect(subject.stack.first.call).to eq 1
+      expect(subject.stack.last.call).to eq 2
+    end
+
+    it "creates a stack from hashes passing them as opts" do
+      expect(return_one).to receive(:new).with(:notifier, opts: :for_one)
+      expect(return_two).to receive(:new).with(:notifier, opts: :for_two)
+
+      subject = described_class.new(:notifier)
+      subject.set return_one: { opts: :for_one },
+                  return_two: { opts: :for_two }
+    end
+
+    it "raises if a middleware is missing" do
+      expect do
+        described_class.new(:notifier).set(:missing)
+      end.to raise_exception KeyError
+    end
+  end
+
+  describe "#call" do
+    it "calls the middleware in order, passing return of each to the next" do
+      allow(return_one).to receive(:new).and_return(return_one)
+      allow(return_two).to receive(:new).and_return(return_two)
+      allow(return_three).to receive(:new).and_return(return_three)
+
+      subject = described_class.new(:notifier)
+      subject.set(:return_one, :return_three, :return_two)
+
+      expect(return_one).to receive(:call).with(5)
+      expect(return_three).to receive(:call).with(1)
+      expect(return_two).to receive(:call).with(3)
+
+      expect(subject.call(5)).to eq 2
+    end
+  end
+end

data/spec/lib/slack-notifier/payload_middleware_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+RSpec.describe Slack::Notifier::PayloadMiddleware do
+  before(:each) do
+    @registry_backup = described_class.registry.dup
+    Slack::Notifier::PayloadMiddleware.send(:remove_instance_variable, :@registry)
+  end
+
+  after(:each) do
+    described_class.send(:remove_instance_variable, :@registry)
+    described_class.send(:instance_variable_set, :@registry, @registry_backup)
+  end
+
+  describe "::registry" do
+    it "returns a hash if nothing set" do
+      expect(described_class.registry).to eq({})
+    end
+
+    it "returns memoized version if already set" do
+      described_class.instance_variable_set(:@registry, "hodor")
+      expect(described_class.registry).to eq "hodor"
+    end
+  end
+
+  describe "::register" do
+    it "adds given class to key in registry" do
+      MyClass = Struct.new(:myclass)
+      described_class.register MyClass, :my_class
+
+      expect(described_class.registry[:my_class]).to eq MyClass
+    end
+  end
+end