slack-notifier 1.5.1 → 2.4.0

data/spec/integration/ping_integration_test.rb

@@ -1,7 +1,16 @@
+# frozen_string_literal: true
 # encoding: utf-8
-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"}]
+require_relative "../../lib/slack-notifier"
+
+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", channel: ["#general", "#random"]
+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, :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-notifier/payload_middleware/at_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Notifier::PayloadMiddleware::At do
+  it "can handle array at" do
+    subject = described_class.new(:notifier)
+    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(:notifier)
+    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(:notifier)
+    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-notifier/payload_middleware/base_spec.rb

@@ -0,0 +1,76 @@
+# 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/channels_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Notifier::PayloadMiddleware::Channels do
+  it "leaves string channels alone" do
+    subject = described_class.new(:notifier)
+    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(:notifier)
+    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-notifier/payload_middleware/format_attachments_spec.rb

@@ -0,0 +1,48 @@
+# 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: %i[html markdown])
+    subject.call("attachments" => [{ "text" => "hello" }])
+
+    subject = described_class.new(:notifier)
+    expect(Slack::Notifier::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(:notifier)
+    expect(Slack::Notifier::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(:notifier)
+
+    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(:notifier)
+
+    expect(subject.call(payload)).to eq payload
+  end
+end

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

@@ -0,0 +1,27 @@
+# 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: %i[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,119 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Notifier::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::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_one_twice, :return_one_twice
+    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
+
+    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(:notifier)
+      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(:notifier)
+      subject.set(:return_one_twice, :return_one_twice, :return_two)
+
+      expect(subject.call(5)).to eq [2, 2, 2, 2]
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# 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

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe Slack::Notifier::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::Notifier::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::Notifier::APIError,
+                                                 /something_bad \(HTTP Code 400\)/)
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# rubocop:disable Metrics/LineLength
+RSpec.describe Slack::Notifier::Util::LinkFormatter do
+  describe "initialize & formatted" do
+    it "can be initialized without format args" do
+      subject = described_class.new("Hello World")
+      expect(subject.formatted()).to eq("Hello World")
+    end
+
+    it "can be initialized with format args" do
+      subject = described_class.new("Hello World", formats: [:html])
+      expect(subject.formatted()).to eq("Hello World")
+    end
+  end
+  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 [](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