slack-messenger 2.3.3

data/lib/slack-messenger/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Slack
+  class Messenger
+    VERSION = "2.3.3".freeze # rubocop:disable Style/RedundantFreeze
+  end
+end

data/spec/end_to_end_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+RSpec.describe Slack::Messenger 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 messenger test" } =>
+    { payload: { text: "hello/こんにちは from messenger 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: nil, attachments: [{ text: "attachment message" }] } =>
+    { payload: { text: nil, attachments: [{ text: "attachment message" }] } },
+
+    { 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" }] } },
+
+    { attachments: { color: "#000",
+                     text: nil,
+                     fallback: "fallback message" } } =>
+    { payload: { attachments: [{ color: "#000",
+                                 text: nil,
+                                 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::Messenger::Util::HTTPClient", post: nil)
+      messenger          = Slack::Messenger.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)
+
+      messenger.post(args)
+    end
+  end
+
+  it "applies options given to middleware" do
+    client   = class_double("Slack::Messenger::Util::HTTPClient", post: nil)
+    messenger = Slack::Messenger.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)
+
+    messenger.post text: "Hello [world](http://example.com)!"
+  end
+end

data/spec/integration/ping_integration_test.rb

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

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Messenger::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::Messenger::Util::HTTPClient
+    end
+
+    it "sets a new client class if given one" do
+      new_client = class_double("Slack::Messenger::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, :at] if not set" do
+      subject = described_class.new
+
+      expect(subject.middleware).to eq %i[format_message format_attachments at channels]
+    end
+
+    it "takes an array or a splat of args" do
+      subject = described_class.new
+
+      subject.middleware :layer, :two
+      expect(subject.middleware).to eq %i[layer two]
+
+      subject.middleware %i[one layer]
+      expect(subject.middleware).to eq %i[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-messenger/payload_middleware/at_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Messenger::PayloadMiddleware::At do
+  it "can handle array at" do
+    subject = described_class.new(:messenger)
+    payload = { text: "hello", at: %i[john ken here] }
+
+    expect(subject.call(payload)).to eq text: "<@john> <@ken> <!here> hello"
+  end
+
+  it "can handle single at option" do
+    subject = described_class.new(:messenger)
+    payload = { text: "hello", at: :alice }
+
+    expect(subject.call(payload)).to eq text: "<@alice> hello"
+  end
+
+  it "generates :text in payload if given :at & no :text" do
+    subject = described_class.new(:messenger)
+    input_payload  = { at: [:here], attachments: [{ text: "hello" }] }
+    output_payload = { text: "<!here> ", attachments: [{ text: "hello" }] }
+
+    expect(subject.call(input_payload)).to eq output_payload
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Messenger::PayloadMiddleware::Base do
+  before(:each) do
+    @registry_backup = Slack::Messenger::PayloadMiddleware.registry.dup
+    Slack::Messenger::PayloadMiddleware.send(:remove_instance_variable, :@registry)
+  end
+
+  after(:each) do
+    # cleanup middleware registry
+    Slack::Messenger::PayloadMiddleware.registry
+    Slack::Messenger::PayloadMiddleware.send(:remove_instance_variable, :@registry)
+
+    # cleanup object constants
+    Object.send(:remove_const, :Subject) if Object.constants.include?(:Subject)
+    Slack::Messenger::PayloadMiddleware.send(:instance_variable_set, :@registry, @registry_backup)
+  end
+
+  describe "::middleware_name" do
+    it "registers class w/ given name" do
+      class Subject < Slack::Messenger::PayloadMiddleware::Base
+      end
+
+      expect(Slack::Messenger::PayloadMiddleware)
+        .to receive(:register).with(Subject, :subject)
+
+      class Subject
+        middleware_name :subject
+      end
+    end
+
+    it "uses symbolized name to register" do
+      class Subject < Slack::Messenger::PayloadMiddleware::Base
+      end
+
+      expect(Slack::Messenger::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::Messenger::PayloadMiddleware::Base
+        options foo: :bar
+      end
+
+      subject = Subject.new(:messenger)
+      expect(subject.options).to eq foo: :bar
+
+      subject = Subject.new(:messenger, foo: :baz)
+      expect(subject.options).to eq foo: :baz
+    end
+  end
+
+  describe "#initialize" do
+    it "sets given messenger as messenger" do
+      expect(described_class.new(:messenger).messenger).to eq :messenger
+    end
+
+    it "sets given options as opts" do
+      expect(described_class.new(:messenger, 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(:messenger).call
+      end.to raise_exception NoMethodError
+    end
+  end
+end

data/spec/lib/slack-messenger/payload_middleware/channels_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Messenger::PayloadMiddleware::Channels do
+  it "leaves string channels alone" do
+    subject = described_class.new(:messenger)
+    payload = { text: "hello", channel: "hodor" }
+
+    expect(subject.call(payload)).to eq text: "hello", channel: "hodor"
+  end
+
+  it "splits payload into multiple if given an array of channels" do
+    subject = described_class.new(:messenger)
+    payload = { text: "hello", channel: %w[foo hodor] }
+
+    expect(subject.call(payload)).to eq [
+      { text: "hello", channel: "foo" },
+      { text: "hello", channel: "hodor" }
+    ]
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Messenger::PayloadMiddleware::FormatAttachments do
+  it "passes the text of attachments through linkformatter with options[:formats]" do
+    subject = described_class.new(:messenger, formats: [:html])
+    expect(Slack::Messenger::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(:messenger)
+    expect(Slack::Messenger::Util::LinkFormatter).to receive(:format)
+      .with("hello", formats: %i[html markdown])
+    subject.call("attachments" => [{ "text" => "hello" }])
+
+    subject = described_class.new(:messenger)
+    expect(Slack::Messenger::Util::LinkFormatter).to receive(:format)
+      .with("hello", formats: %i[html markdown])
+    subject.call(attachments: [{ text: "hello" }])
+  end
+
+  it "can handle a single attachment" do
+    subject = described_class.new(:messenger)
+    expect(Slack::Messenger::Util::LinkFormatter).to receive(:format)
+      .with("hello", formats: %i[html markdown])
+    subject.call(attachments: { text: "hello" })
+  end
+
+  it "wraps attachment into array if given as a single hash" do
+    params = {
+      attachments: { text: "hello" }
+    }
+    payload = {
+      attachments: [{ text: "hello" }]
+    }
+    subject = described_class.new(:messenger)
+
+    expect(subject.call(params)).to eq payload
+  end
+
+  it "returns the payload unmodified if not :attachments key" do
+    payload = { foo: :bar }
+    subject = described_class.new(:messenger)
+
+    expect(subject.call(payload)).to eq payload
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Messenger::PayloadMiddleware::FormatMessage do
+  it "passes the text through linkformatter with options[:formats]" do
+    subject = described_class.new(:messenger, formats: [:html])
+    expect(Slack::Messenger::Util::LinkFormatter).to receive(:format)
+      .with("hello", formats: [:html])
+    subject.call(text: "hello")
+
+    subject = described_class.new(:messenger)
+    expect(Slack::Messenger::Util::LinkFormatter).to receive(:format)
+      .with("hello", formats: %i[html markdown])
+    subject.call(text: "hello")
+
+    subject = described_class.new(:messenger, formats: [:markdown])
+    expect(Slack::Messenger::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(:messenger)
+
+    expect(subject.call(payload)).to eq payload
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Messenger::PayloadMiddleware::Stack do
+  let(:return_one) do
+    double(call: 1)
+  end
+
+  let(:return_one_twice) do
+    double(call: [1, 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::Messenger::PayloadMiddleware.registry.dup
+    Slack::Messenger::PayloadMiddleware.send(:remove_instance_variable, :@registry)
+
+    Slack::Messenger::PayloadMiddleware.register return_one, :return_one
+    Slack::Messenger::PayloadMiddleware.register return_one_twice, :return_one_twice
+    Slack::Messenger::PayloadMiddleware.register return_two, :return_two
+    Slack::Messenger::PayloadMiddleware.register return_three, :return_three
+  end
+
+  after(:each) do
+    # cleanup middleware registry
+    Slack::Messenger::PayloadMiddleware.send(:remove_instance_variable, :@registry)
+    Slack::Messenger::PayloadMiddleware.send(:instance_variable_set, :@registry, @registry_backup)
+  end
+
+  describe "::initialize" do
+    it "sets messenger to given messenger" do
+      expect(described_class.new(:messenger).messenger).to eq :messenger
+    end
+
+    it "has empty stack" do
+      expect(described_class.new(:messenger).stack).to match_array []
+    end
+  end
+
+  describe "#set" do
+    it "initializes each middleware w/ the messenger instance" do
+      expect(return_one).to receive(:new).with(:messenger)
+      expect(return_two).to receive(:new).with(:messenger)
+
+      described_class.new(:messenger).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(:messenger)
+      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(:messenger, opts: :for_one)
+      expect(return_two).to receive(:new).with(:messenger, opts: :for_two)
+
+      subject = described_class.new(:messenger)
+      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(:messenger).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(:messenger)
+      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
+
+    it "allows any middleware to return an array but other's don't need special behavior" do
+      allow(return_one_twice).to receive(:new).and_return(return_one_twice)
+      allow(return_two).to receive(:new).and_return(return_two)
+
+      subject = described_class.new(:messenger)
+      subject.set(:return_one_twice, :return_two)
+
+      expect(subject.call(5)).to eq [2, 2]
+    end
+
+    it "handles multiple middleware splitting payload" do
+      allow(return_one_twice).to receive(:new).and_return(return_one_twice)
+      allow(return_two).to receive(:new).and_return(return_two)
+
+      subject = described_class.new(:messenger)
+      subject.set(:return_one_twice, :return_one_twice, :return_two)
+
+      expect(subject.call(5)).to eq [2, 2, 2, 2]
+    end
+  end
+end