slack-messenger 2.3.3

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Messenger::PayloadMiddleware do
+  before(:each) do
+    @registry_backup = described_class.registry.dup
+    Slack::Messenger::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

data/spec/lib/slack-messenger/util/http_client_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Messenger::Util::HTTPClient do
+  describe "::post" do
+    it "initializes Util::HTTPClient with the given uri and params then calls" do
+      http_post_double = instance_double("Slack::Messenger::Util::HTTPClient")
+
+      expect(described_class)
+        .to receive(:new).with("uri", "params")
+                         .and_return(http_post_double)
+      expect(http_post_double).to receive(:call)
+
+      described_class.post "uri", "params"
+    end
+
+    # http_post is really tested in the integration spec,
+    # where the internals are run through
+  end
+
+  describe "#initialize" do
+    it "allows setting of options for Net::HTTP" do
+      net_http_double = instance_double("Net::HTTP")
+      http_client     = described_class.new URI.parse("http://example.com"),
+                                            http_options: { open_timeout: 5 }
+
+      allow(Net::HTTP).to receive(:new).and_return(net_http_double)
+      allow(net_http_double).to receive(:use_ssl=)
+      allow(net_http_double).to receive(:request).with(anything) do
+        Net::HTTPOK.new("GET", "200", "OK")
+      end
+
+      expect(net_http_double).to receive(:open_timeout=).with(5)
+
+      http_client.call
+    end
+  end
+
+  describe "#call" do
+    it "raises an error when the response is unsuccessful" do
+      net_http_double = instance_double("Net::HTTP")
+      http_client = described_class.new URI.parse("http://example.com"), {}
+      bad_request = Net::HTTPBadRequest.new("GET", "400", "Bad Request")
+
+      allow(bad_request).to receive(:body).and_return("something_bad")
+      allow(Net::HTTP).to receive(:new).and_return(net_http_double)
+      allow(net_http_double).to receive(:use_ssl=)
+      allow(net_http_double).to receive(:request).with(anything) do
+        bad_request
+      end
+
+      expect { http_client.call }.to raise_error(Slack::Messenger::APIError,
+                                                 /something_bad \(HTTP Code 400\)/)
+    end
+  end
+end

data/spec/lib/slack-messenger/util/link_formatter_spec.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# rubocop:disable Metrics/LineLength
+RSpec.describe Slack::Messenger::Util::LinkFormatter do
+  describe "::format" do
+    it "formats html links" do
+      formatted = described_class.format("Hello World, enjoy <a href='http://example.com'>this</a>.")
+      expect(formatted).to include("<http://example.com|this>")
+    end
+
+    it "formats markdown links" do
+      formatted = described_class.format("Hello World, enjoy [this](http://example.com).")
+      expect(formatted).to include("<http://example.com|this>")
+    end
+
+    it "formats markdown links in brackets" do
+      formatted = described_class.format("Hello World, enjoy [[this](http://example.com) in brackets].")
+      expect(formatted).to eq("Hello World, enjoy [<http://example.com|this> in brackets].")
+    end
+
+    it "formats markdown links with no title" do
+      formatted = described_class.format("Hello World, enjoy [](http://example.com).")
+      expect(formatted).to include("<http://example.com>")
+    end
+
+    it "handles multiple html links" do
+      formatted = described_class.format("Hello World, enjoy <a href='http://example.com'>this</a><a href='http://example2.com'>this2</a>.")
+      expect(formatted).to include("<http://example.com|this>")
+      expect(formatted).to include("<http://example2.com|this2>")
+    end
+
+    it "handles multiple markdown links" do
+      formatted = described_class.format("Hello World, enjoy [this](http://example.com)[this2](http://example2.com).")
+      expect(formatted).to include("<http://example.com|this>")
+      expect(formatted).to include("<http://example2.com|this2>")
+    end
+
+    it "handles mixed html & markdown links" do
+      formatted = described_class.format("Hello World, enjoy [this](http://example.com)<a href='http://example2.com'>this2</a>.")
+      expect(formatted).to include("<http://example.com|this>")
+      expect(formatted).to include("<http://example2.com|this2>")
+    end
+
+    if "".respond_to? :scrub
+      context "when on ruby 2.1+ or have string-scrub installed" do
+        it "handles invalid unicode sequences" do
+          expect do
+            described_class.format("This sequence is invalid: \255")
+          end.not_to raise_error
+        end
+
+        it "replaces invalid unicode sequences with the unicode replacement character" do
+          formatted = described_class.format("\255")
+          expect(formatted).to eq "\uFFFD"
+        end
+      end
+    end
+
+    it "doesn't replace valid Japanese" do
+      formatted = described_class.format("こんにちは")
+      expect(formatted).to eq "こんにちは"
+    end
+
+    it "handles mailto links in markdown" do
+      formatted = described_class.format("[John](mailto:john@example.com)")
+      expect(formatted).to eq "<mailto:john@example.com|John>"
+    end
+
+    it "handles mailto links in html" do
+      formatted = described_class.format("<a href='mailto:john@example.com'>John</a>")
+      expect(formatted).to eq "<mailto:john@example.com|John>"
+    end
+
+    it "handles links with trailing parentheses" do
+      formatted = described_class.format("Hello World, enjoy [foo(bar)](http://example.com/foo(bar))<a href='http://example.com/bar(foo)'>bar(foo)</a>")
+      expect(formatted).to include("http://example.com/foo(bar)|foo(bar)")
+      expect(formatted).to include("http://example.com/bar(foo)|bar(foo)")
+    end
+
+    it "formats a number of differently formatted links" do
+      input_output = {
+        "Hello World, enjoy [this](http://example.com)." =>
+          "Hello World, enjoy <http://example.com|this>.",
+
+        "Hello World, enjoy [[this](http://example.com) in brackets]." =>
+          "Hello World, enjoy [<http://example.com|this> in brackets].",
+
+        "Hello World, enjoy ([this](http://example.com) in parens)." =>
+          "Hello World, enjoy (<http://example.com|this> in parens).",
+
+        "Hello World, enjoy ([this](http://example.com))." =>
+          "Hello World, enjoy (<http://example.com|this>).",
+
+        "Hello World, enjoy [](http://example.com)." =>
+          "Hello World, enjoy <http://example.com>.",
+
+        "Hello World, enjoy [link with query](http://example.com?foo=bar)." =>
+          "Hello World, enjoy <http://example.com?foo=bar|link with query>.",
+
+        "Hello World, enjoy [link with fragment](http://example.com/#foo-bar)." =>
+          "Hello World, enjoy <http://example.com/#foo-bar|link with fragment>.",
+
+        "Hello World, enjoy [link with parens](http://example.com/foo(bar)/baz)." =>
+          "Hello World, enjoy <http://example.com/foo(bar)/baz|link with parens>.",
+
+        "Hello World, enjoy [link with query](http://example.com/(parens)?foo=bar)." =>
+          "Hello World, enjoy <http://example.com/(parens)?foo=bar|link with query>.",
+
+        "Hello World, enjoy [link with parens](http://example.com/baz?bang=foo(bar))." =>
+          "Hello World, enjoy <http://example.com/baz?bang=foo(bar)|link with parens>.",
+
+        "Hello World, enjoy [link with fragment](http://example.com/(parens)#foo-bar)." =>
+          "Hello World, enjoy <http://example.com/(parens)#foo-bar|link with fragment>.",
+
+        "Hello World, enjoy [link with fragment](http://example.com/#foo-bar=(baz))." =>
+          "Hello World, enjoy <http://example.com/#foo-bar=(baz)|link with fragment>.",
+
+        "Hello World, enjoy [this](http://example.com?foo=bar)[this2](http://example2.com)." =>
+          "Hello World, enjoy <http://example.com?foo=bar|this><http://example2.com|this2>.",
+
+        "Hello World, enjoy [this](http://example.com?foo=bar) [this2](http://example2.com/#fragment)." =>
+          "Hello World, enjoy <http://example.com?foo=bar|this> <http://example2.com/#fragment|this2>.",
+
+        "Hello World, enjoy [this](http://example.com)<a href='http://example2.com'>this2</a>." =>
+          "Hello World, enjoy <http://example.com|this><http://example2.com|this2>.",
+
+        "Hello world, [John](mailto:john@example.com)." =>
+          "Hello world, <mailto:john@example.com|John>.",
+
+        "Hello World, enjoy [foo(bar)](http://example.com/foo(bar))<a href='http://example.com/bar(foo)'>bar(foo)</a>" =>
+          "Hello World, enjoy <http://example.com/foo(bar)|foo(bar)><http://example.com/bar(foo)|bar(foo)>"
+      }
+
+      input_output.each do |input, output|
+        expect(described_class.format(input)).to eq output
+      end
+    end
+
+    context "with a configured stack" do
+      it "only formats html if html is the only item in formats" do
+        formatted = described_class.format("Hello World, enjoy [this](http://example.com)<a href='http://example2.com'>this2</a>.", formats: [:html])
+        expect(formatted).to eq "Hello World, enjoy [this](http://example.com)<http://example2.com|this2>."
+      end
+      it "only formats markdown if markdown is the only item in formats" do
+        formatted = described_class.format("Hello World, enjoy [this](http://example.com)<a href='http://example2.com'>this2</a>.", formats: [:markdown])
+        expect(formatted).to eq "Hello World, enjoy <http://example.com|this><a href='http://example2.com'>this2</a>."
+      end
+      it "doesn't format if formats is empty" do
+        formatted = described_class.format("Hello World, enjoy [this](http://example.com)<a href='http://example2.com'>this2</a>.", formats: [])
+        expect(formatted).to eq "Hello World, enjoy [this](http://example.com)<a href='http://example2.com'>this2</a>."
+      end
+    end
+  end
+end

data/spec/lib/slack-messenger_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Messenger do
+  let(:mock_http) do
+    class_double("Slack::Messenger::Util::HTTPClient", post: :posted)
+  end
+
+  subject { described_class.new "http://example.com", http_client: mock_http }
+
+  describe "#initialize" do
+    it "sets the given hook_url to the endpoint URI" do
+      expect(subject.endpoint).to eq URI.parse("http://example.com")
+    end
+
+    it "sets the default_payload options" do
+      subject = described_class.new "http://example.com", channel: "foo"
+      expect(subject.config.defaults[:channel]).to eq "foo"
+    end
+
+    it "sets a custom http client" do
+      subject = described_class.new "http://example.com", http_client: mock_http
+      expect(subject.config.http_client).to eq mock_http
+    end
+
+    describe "when given a block" do
+      it "yields the config object" do
+        test_double = double("Slack::Messenger::Config", defaults: {}, middleware: [])
+        allow_any_instance_of(Slack::Messenger).to receive(:config).and_return(test_double)
+
+        expect(test_double).to receive(:test_init_method).with("foo")
+
+        described_class.new "http://example.com" do
+          test_init_method "foo"
+        end
+      end
+    end
+  end
+
+  describe "#ping" do
+    it "calls #post with the message as the text key in #post" do
+      subject = described_class.new "http://example.com"
+      expect(subject).to receive(:post).with text: "message"
+
+      subject.ping "message"
+    end
+  end
+
+  describe "#post" do
+    def messenger_with_defaults
+      mock_client = mock_http
+      described_class.new "http://example.com" do
+        defaults channel: "default",
+                 user:    "rocket"
+        http_client mock_client
+      end
+    end
+
+    it "uses the defaults set on initialization" do
+      subject = messenger_with_defaults
+
+      expect(mock_http).to receive(:post).with(
+        URI.parse("http://example.com"),
+        payload: '{"channel":"default","user":"rocket","text":"hello"}'
+      )
+
+      subject.post text: "hello"
+    end
+
+    it "allows overriding the set defaults" do
+      subject = messenger_with_defaults
+
+      expect(mock_http).to receive(:post).with(
+        URI.parse("http://example.com"),
+        payload: '{"channel":"new","user":"ship","text":"hello"}'
+      )
+
+      subject.post text: "hello", channel: "new", user: "ship"
+    end
+
+    it "calls the middleware stack with the payload" do
+      subject = messenger_with_defaults
+      stack   = instance_double("Slack::Messenger::PayloadMiddleware::Stack")
+      subject.instance_variable_set(:@middleware, stack)
+
+      expect(stack).to receive(:call)
+        .with(channel: "default", user: "rocket")
+        .and_return([test: "stack"])
+
+      expect(mock_http).to receive(:post).with(
+        URI.parse("http://example.com"),
+        payload: '{"test":"stack"}'
+      )
+
+      responses = subject.post
+      expect(responses).to eq([:posted])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rspec"
+require "slack-messenger"
+require "pry" if ENV["DEBUG"]
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_doubled_constant_names = true
+    mocks.verify_partial_doubles        = true
+  end
+
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+  config.disable_monkey_patching!
+
+  config.example_status_persistence_file_path = "spec/examples.txt"
+  config.warnings = ENV["DEBUG"] ? false : true
+
+  config.default_formatter = "doc" if config.files_to_run.one?
+
+  config.order = :random
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: slack-messenger
+version: !ruby/object:Gem::Version
+  version: 2.3.3
+platform: ruby
+authors:
+- Steven Sloan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-09 00:00:00.000000000 Z
+dependencies: []
+description: " A slim ruby wrapper for posting to slack webhooks "
+email:
+- stevenosloan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/slack-messenger.rb
+- lib/slack-messenger/config.rb
+- lib/slack-messenger/payload_middleware.rb
+- lib/slack-messenger/payload_middleware/at.rb
+- lib/slack-messenger/payload_middleware/base.rb
+- lib/slack-messenger/payload_middleware/channels.rb
+- lib/slack-messenger/payload_middleware/format_attachments.rb
+- lib/slack-messenger/payload_middleware/format_message.rb
+- lib/slack-messenger/payload_middleware/stack.rb
+- lib/slack-messenger/util/escape.rb
+- lib/slack-messenger/util/http_client.rb
+- lib/slack-messenger/util/link_formatter.rb
+- lib/slack-messenger/version.rb
+- spec/end_to_end_spec.rb
+- spec/integration/ping_integration_test.rb
+- spec/lib/slack-messenger/config_spec.rb
+- spec/lib/slack-messenger/payload_middleware/at_spec.rb
+- spec/lib/slack-messenger/payload_middleware/base_spec.rb
+- spec/lib/slack-messenger/payload_middleware/channels_spec.rb
+- spec/lib/slack-messenger/payload_middleware/format_attachments_spec.rb
+- spec/lib/slack-messenger/payload_middleware/format_message_spec.rb
+- spec/lib/slack-messenger/payload_middleware/stack_spec.rb
+- spec/lib/slack-messenger/payload_middleware_spec.rb
+- spec/lib/slack-messenger/util/http_client_spec.rb
+- spec/lib/slack-messenger/util/link_formatter_spec.rb
+- spec/lib/slack-messenger_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/stevenosloan/slack-messenger
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A slim ruby wrapper for posting to slack webhooks
+test_files:
+- spec/spec_helper.rb
+- spec/integration/ping_integration_test.rb
+- spec/lib/slack-messenger_spec.rb
+- spec/lib/slack-messenger/config_spec.rb
+- spec/lib/slack-messenger/util/http_client_spec.rb
+- spec/lib/slack-messenger/util/link_formatter_spec.rb
+- spec/lib/slack-messenger/payload_middleware/at_spec.rb
+- spec/lib/slack-messenger/payload_middleware/format_attachments_spec.rb
+- spec/lib/slack-messenger/payload_middleware/channels_spec.rb
+- spec/lib/slack-messenger/payload_middleware/stack_spec.rb
+- spec/lib/slack-messenger/payload_middleware/format_message_spec.rb
+- spec/lib/slack-messenger/payload_middleware/base_spec.rb
+- spec/lib/slack-messenger/payload_middleware_spec.rb
+- spec/end_to_end_spec.rb