uniform_notifier 1.11.0 → 1.12.0

data/spec/uniform_notifier/honeybadger_spec.rb

@@ -1,25 +1,27 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 class Honeybadger
   # mock Honeybadger
 end
 
 RSpec.describe UniformNotifier::HoneybadgerNotifier do
-  it "should not notify honeybadger" do
-    expect(UniformNotifier::HoneybadgerNotifier.out_of_channel_notify(:title => "notify honeybadger")).to be_nil
+  it 'should not notify honeybadger' do
+    expect(UniformNotifier::HoneybadgerNotifier.out_of_channel_notify(title: 'notify honeybadger')).to be_nil
   end
 
-  it "should notify honeybadger" do
-    expect(Honeybadger).to receive(:notify).with(UniformNotifier::Exception.new("notify honeybadger"), {})
+  it 'should notify honeybadger' do
+    expect(Honeybadger).to receive(:notify).with(UniformNotifier::Exception.new('notify honeybadger'), {})
 
     UniformNotifier.honeybadger = true
-    UniformNotifier::HoneybadgerNotifier.out_of_channel_notify(:title => "notify honeybadger")
+    UniformNotifier::HoneybadgerNotifier.out_of_channel_notify(title: 'notify honeybadger')
   end
 
-  it "should notify honeybadger" do
-    expect(Honeybadger).to receive(:notify).with(UniformNotifier::Exception.new("notify honeybadger"), :foo => :bar)
+  it 'should notify honeybadger' do
+    expect(Honeybadger).to receive(:notify).with(UniformNotifier::Exception.new('notify honeybadger'), foo: :bar)
 
-    UniformNotifier.honeybadger = { :foo => :bar }
-    UniformNotifier::HoneybadgerNotifier.out_of_channel_notify("notify honeybadger")
+    UniformNotifier.honeybadger = { foo: :bar }
+    UniformNotifier::HoneybadgerNotifier.out_of_channel_notify('notify honeybadger')
   end
 end

data/spec/uniform_notifier/javascript_alert_spec.rb

@@ -1,16 +1,36 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 RSpec.describe UniformNotifier::JavascriptAlert do
-  it "should not notify message" do
-    expect(UniformNotifier::JavascriptAlert.inline_notify(:title => "javascript alert!")).to be_nil
+  it 'should not notify message' do
+    expect(UniformNotifier::JavascriptAlert.inline_notify(title: 'javascript alert!')).to be_nil
   end
 
-  it "should notify message" do
+  it 'should notify message' do
     UniformNotifier.alert = true
-    expect(UniformNotifier::JavascriptAlert.inline_notify(:title => "javascript alert!")).to eq <<-CODE
-<script type="text/javascript">/*<![CDATA[*/
-alert( "javascript alert!" );
-/*]]>*/</script>
-CODE
+    expect(UniformNotifier::JavascriptAlert.inline_notify(title: 'javascript alert!')).to eq <<~CODE
+      <script type="text/javascript">/*<![CDATA[*/
+      alert( "javascript alert!" );
+      /*]]>*/</script>
+    CODE
+  end
+
+  it 'should accept custom attributes' do
+    UniformNotifier.alert = { attributes: { nonce: 'my-nonce', 'data-key' => :value } }
+    expect(UniformNotifier::JavascriptAlert.inline_notify(title: 'javascript alert!')).to eq <<~CODE
+      <script type="text/javascript" nonce="my-nonce" data-key="value">/*<![CDATA[*/
+      alert( "javascript alert!" );
+      /*]]>*/</script>
+    CODE
+  end
+
+  it 'should have default attributes if no attributes settings exist' do
+    UniformNotifier.alert = {}
+    expect(UniformNotifier::JavascriptAlert.inline_notify(title: 'javascript alert!')).to eq <<~CODE
+      <script type="text/javascript">/*<![CDATA[*/
+      alert( "javascript alert!" );
+      /*]]>*/</script>
+    CODE
   end
 end

data/spec/uniform_notifier/javascript_console_spec.rb

@@ -1,25 +1,63 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 RSpec.describe UniformNotifier::JavascriptConsole do
-  it "should not notify message" do
-    expect(UniformNotifier::JavascriptConsole.inline_notify(:title => "javascript console!")).to be_nil
+  it 'should not notify message' do
+    expect(UniformNotifier::JavascriptConsole.inline_notify(title: 'javascript console!')).to be_nil
   end
 
-  it "should notify message" do
+  it 'should notify message' do
     UniformNotifier.console = true
-    expect(UniformNotifier::JavascriptConsole.inline_notify(:title => "javascript console!")).to eq <<-CODE
-<script type="text/javascript">/*<![CDATA[*/
-if (typeof(console) !== 'undefined' && console.log) {
-  if (console.groupCollapsed && console.groupEnd) {
-    console.groupCollapsed(#{"Uniform Notifier".inspect});
-    console.log(#{"javascript console!".inspect});
-    console.groupEnd();
-  } else {
-    console.log(#{"javascript console!".inspect});
-  }
-}
-
-/*]]>*/</script>
+    expect(UniformNotifier::JavascriptConsole.inline_notify(title: 'javascript console!')).to eq <<~CODE
+      <script type="text/javascript">/*<![CDATA[*/
+      if (typeof(console) !== 'undefined' && console.log) {
+        if (console.groupCollapsed && console.groupEnd) {
+          console.groupCollapsed(#{'Uniform Notifier'.inspect});
+          console.log(#{'javascript console!'.inspect});
+          console.groupEnd();
+        } else {
+          console.log(#{'javascript console!'.inspect});
+        }
+      }
+
+      /*]]>*/</script>
+    CODE
+  end
+
+  it 'should accept custom attributes' do
+    UniformNotifier.console = { attributes: { nonce: 'my-nonce', 'data-key' => :value } }
+    expect(UniformNotifier::JavascriptConsole.inline_notify(title: 'javascript console!')).to eq <<~CODE
+      <script type="text/javascript" nonce="my-nonce" data-key="value">/*<![CDATA[*/
+      if (typeof(console) !== 'undefined' && console.log) {
+        if (console.groupCollapsed && console.groupEnd) {
+          console.groupCollapsed(#{'Uniform Notifier'.inspect});
+          console.log(#{'javascript console!'.inspect});
+          console.groupEnd();
+        } else {
+          console.log(#{'javascript console!'.inspect});
+        }
+      }
+
+      /*]]>*/</script>
+    CODE
+  end
+
+  it 'should have default attributes if no attributes settings exist' do
+    UniformNotifier.console = {}
+    expect(UniformNotifier::JavascriptConsole.inline_notify(title: 'javascript console!')).to eq <<~CODE
+      <script type="text/javascript">/*<![CDATA[*/
+      if (typeof(console) !== 'undefined' && console.log) {
+        if (console.groupCollapsed && console.groupEnd) {
+          console.groupCollapsed(#{'Uniform Notifier'.inspect});
+          console.log(#{'javascript console!'.inspect});
+          console.groupEnd();
+        } else {
+          console.log(#{'javascript console!'.inspect});
+        }
+      }
+
+      /*]]>*/</script>
     CODE
   end
 end

data/spec/uniform_notifier/rails_logger_spec.rb

@@ -1,20 +1,22 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 class Rails
   # mock Rails
 end
 
 RSpec.describe UniformNotifier::RailsLogger do
-  it "should not notify rails logger" do
-    expect(UniformNotifier::RailsLogger.out_of_channel_notify(:title => "notify rails logger")).to be_nil
+  it 'should not notify rails logger' do
+    expect(UniformNotifier::RailsLogger.out_of_channel_notify(title: 'notify rails logger')).to be_nil
   end
 
-  it "should notify rails logger" do
-    logger = double("logger")
+  it 'should notify rails logger' do
+    logger = double('logger')
     expect(Rails).to receive(:logger).and_return(logger)
-    expect(logger).to receive(:warn).with("notify rails logger")
+    expect(logger).to receive(:warn).with('notify rails logger')
 
     UniformNotifier.rails_logger = true
-    UniformNotifier::RailsLogger.out_of_channel_notify(:title => "notify rails logger")
+    UniformNotifier::RailsLogger.out_of_channel_notify(title: 'notify rails logger')
   end
 end

data/spec/uniform_notifier/raise_spec.rb

@@ -1,31 +1,33 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 RSpec.describe UniformNotifier::Raise do
-  it "should not notify message" do
-    expect(UniformNotifier::Raise.out_of_channel_notify(:title => "notification")).to be_nil
+  it 'should not notify message' do
+    expect(UniformNotifier::Raise.out_of_channel_notify(title: 'notification')).to be_nil
   end
 
-  it "should raise error of the default class" do
+  it 'should raise error of the default class' do
     UniformNotifier.raise = true
     expect {
-      UniformNotifier::Raise.out_of_channel_notify(:title => "notification")
-    }.to raise_error(UniformNotifier::Exception, "notification")
+      UniformNotifier::Raise.out_of_channel_notify(title: 'notification')
+    }.to raise_error(UniformNotifier::Exception, 'notification')
   end
 
-  it "allows the user to override the default exception class" do
+  it 'allows the user to override the default exception class' do
     klass = Class.new(Exception)
     UniformNotifier.raise = klass
     expect {
-      UniformNotifier::Raise.out_of_channel_notify(:title => "notification")
-    }.to raise_error(klass, "notification")
+      UniformNotifier::Raise.out_of_channel_notify(title: 'notification')
+    }.to raise_error(klass, 'notification')
   end
 
-  it "can be turned from on to off again" do
+  it 'can be turned from on to off again' do
     UniformNotifier.raise = true
     UniformNotifier.raise = false
 
     expect {
-      UniformNotifier::Raise.out_of_channel_notify(:title => "notification")
+      UniformNotifier::Raise.out_of_channel_notify(title: 'notification')
     }.not_to raise_error
   end
 end

data/spec/uniform_notifier/rollbar_spec.rb

@@ -1,18 +1,20 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 class Rollbar
   # mock Rollbar
 end
 
 RSpec.describe UniformNotifier::RollbarNotifier do
-  it "should not notify rollbar" do
-    expect(UniformNotifier::RollbarNotifier.out_of_channel_notify(:title => "notify rollbar")).to be_nil
+  it 'should not notify rollbar' do
+    expect(UniformNotifier::RollbarNotifier.out_of_channel_notify(title: 'notify rollbar')).to be_nil
   end
 
-  it "should notify rollbar" do
-    expect(Rollbar).to receive(:info).with(UniformNotifier::Exception.new("notify rollbar"))
+  it 'should notify rollbar' do
+    expect(Rollbar).to receive(:info).with(UniformNotifier::Exception.new('notify rollbar'))
 
     UniformNotifier.rollbar = true
-    UniformNotifier::RollbarNotifier.out_of_channel_notify(:title => "notify rollbar")
+    UniformNotifier::RollbarNotifier.out_of_channel_notify(title: 'notify rollbar')
   end
 end

data/spec/uniform_notifier/sentry_spec.rb

@@ -1,25 +1,27 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 class Raven
   # mock Sentry
 end
 
 RSpec.describe UniformNotifier::SentryNotifier do
-  it "should not notify sentry" do
-    expect(UniformNotifier::SentryNotifier.out_of_channel_notify(:title => "notify sentry")).to be_nil
+  it 'should not notify sentry' do
+    expect(UniformNotifier::SentryNotifier.out_of_channel_notify(title: 'notify sentry')).to be_nil
   end
 
-  it "should notify sentry" do
-    expect(Raven).to receive(:capture_exception).with(UniformNotifier::Exception.new("notify sentry"), {})
+  it 'should notify sentry' do
+    expect(Raven).to receive(:capture_exception).with(UniformNotifier::Exception.new('notify sentry'), {})
 
     UniformNotifier.sentry = true
-    UniformNotifier::SentryNotifier.out_of_channel_notify(:title => "notify sentry")
+    UniformNotifier::SentryNotifier.out_of_channel_notify(title: 'notify sentry')
   end
 
-  it "should notify sentry" do
-    expect(Raven).to receive(:capture_exception).with(UniformNotifier::Exception.new("notify sentry"), :foo => :bar)
+  it 'should notify sentry' do
+    expect(Raven).to receive(:capture_exception).with(UniformNotifier::Exception.new('notify sentry'), foo: :bar)
 
-    UniformNotifier.sentry = { :foo => :bar }
-    UniformNotifier::SentryNotifier.out_of_channel_notify("notify sentry")
+    UniformNotifier.sentry = { foo: :bar }
+    UniformNotifier::SentryNotifier.out_of_channel_notify('notify sentry')
   end
 end

data/spec/uniform_notifier/slack_spec.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe UniformNotifier::Slack do
   context 'not enabled' do
     it 'should not notify slack' do
       expect_any_instance_of(Slack::Notifier).to_not receive(:ping)
-      expect(UniformNotifier::Slack.out_of_channel_notify(:title => 'notify slack')).to be_nil
+      expect(UniformNotifier::Slack.out_of_channel_notify(title: 'notify slack')).to be_nil
     end
   end
 
   context 'configuration' do
     context 'no webhook_url is given' do
       it 'should raise an error' do
-        expect{ UniformNotifier.slack = {} }.to raise_error(UniformNotifier::NotificationError)
+        expect { UniformNotifier.slack = {} }.to raise_error(UniformNotifier::NotificationError)
       end
 
       it 'should not notify slack' do
@@ -20,20 +22,20 @@ RSpec.describe UniformNotifier::Slack do
         rescue UniformNotifier::NotificationError
         ensure
           expect_any_instance_of(Slack::Notifier).to_not receive(:ping)
-          expect(UniformNotifier::Slack.out_of_channel_notify(:title => 'notify slack')).to be_nil
+          expect(UniformNotifier::Slack.out_of_channel_notify(title: 'notify slack')).to be_nil
         end
       end
     end
 
     it 'should remove invalid options' do
       expect(Slack::Notifier).to receive(:new).with('http://some.slack.url', {}).and_return(true)
-      UniformNotifier.slack = { :webhook_url => 'http://some.slack.url', :pizza => 'pepperoni' }
+      UniformNotifier.slack = { webhook_url: 'http://some.slack.url', pizza: 'pepperoni' }
       expect(UniformNotifier::Slack.active?).to eq true
     end
 
     it 'should allow username and channel config options' do
-      expect(Slack::Notifier).to receive(:new).with('http://some.slack.url', { :username => 'The Dude', :channel => '#carpets' }).and_return(true)
-      UniformNotifier.slack = { :webhook_url => 'http://some.slack.url', :username => 'The Dude', :channel => '#carpets' }
+      expect(Slack::Notifier).to receive(:new).with('http://some.slack.url', username: 'The Dude', channel: '#carpets').and_return(true)
+      UniformNotifier.slack = { webhook_url: 'http://some.slack.url', username: 'The Dude', channel: '#carpets' }
       expect(UniformNotifier::Slack.active?).to eq true
     end
   end
@@ -45,9 +47,9 @@ RSpec.describe UniformNotifier::Slack do
     end
 
     it 'should notify slack' do
-      UniformNotifier.slack = { :webhook_url => 'http://some.slack.url' }
+      UniformNotifier.slack = { webhook_url: 'http://some.slack.url' }
       expect_any_instance_of(Slack::Notifier).to receive(:ping)
-      expect(UniformNotifier::Slack.out_of_channel_notify(:title => @message)).to eq @message
+      expect(UniformNotifier::Slack.out_of_channel_notify(title: @message)).to eq @message
     end
   end
 end

data/spec/uniform_notifier/terminal_notifier_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe UniformNotifier::TerminalNotifier do
+  it 'should not notify terminal-notifier when disabled' do
+    expect(UniformNotifier::TerminalNotifier.out_of_channel_notify(title: 'notify terminal')).to be_nil
+  end
+
+  it "should raise an exception when terminal-notifier gem isn't available" do
+    UniformNotifier.terminal_notifier = true
+    expect { UniformNotifier::TerminalNotifier.out_of_channel_notify(body: 'body', title: 'notify terminal') }.to raise_error(UniformNotifier::NotificationError, /terminal-notifier gem/)
+  end
+
+  it 'should notify terminal-notifier when enabled' do
+    module TerminalNotifier
+      # mock TerminalNotifier
+    end
+
+    expect(TerminalNotifier).to receive(:notify).with('body', title: 'notify terminal')
+
+    UniformNotifier.terminal_notifier = true
+    UniformNotifier::TerminalNotifier.out_of_channel_notify(body: 'body', title: 'notify terminal')
+  end
+end

data/spec/uniform_notifier/xmpp_spec.rb

@@ -1,50 +1,52 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe UniformNotifier::Xmpp do
-  it "should not notify xmpp" do
-    expect(UniformNotifier::Xmpp.out_of_channel_notify(:title => "notify xmpp")).to be_nil
+  it 'should not notify xmpp' do
+    expect(UniformNotifier::Xmpp.out_of_channel_notify(title: 'notify xmpp')).to be_nil
   end
 
-  it "should notify xmpp without online status" do
-    jid = double("jid")
-    xmpp = double("xmpp")
+  it 'should notify xmpp without online status' do
+    jid = double('jid')
+    xmpp = double('xmpp')
     expect(Jabber::JID).to receive(:new).with('from@gmail.com').and_return(jid)
     expect(Jabber::Client).to receive(:new).with(jid).and_return(xmpp)
     expect(xmpp).to receive(:connect)
     expect(xmpp).to receive(:auth).with('123456')
 
-    message = double("message")
+    message = double('message')
     expect(Jabber::Message).to receive(:new).with('to@gmail.com', 'notify xmpp').and_return(message)
     expect(message).to receive(:set_type).with(:normal).and_return(message)
     expect(message).to receive(:set_subject).with('Uniform Notifier').and_return(message)
     expect(xmpp).to receive(:send).with(message)
 
-    UniformNotifier.xmpp = {:account => 'from@gmail.com', :password => '123456', :receiver => 'to@gmail.com', :show_online_status => false}
-    UniformNotifier::Xmpp.out_of_channel_notify(:title => 'notify xmpp')
+    UniformNotifier.xmpp = { account: 'from@gmail.com', password: '123456', receiver: 'to@gmail.com', show_online_status: false }
+    UniformNotifier::Xmpp.out_of_channel_notify(title: 'notify xmpp')
   end
 
-  it "should notify xmpp with online status" do
-    jid = double("jid")
-    xmpp = double("xmpp")
+  it 'should notify xmpp with online status' do
+    jid = double('jid')
+    xmpp = double('xmpp')
     expect(Jabber::JID).to receive(:new).with('from@gmail.com').and_return(jid)
     expect(Jabber::Client).to receive(:new).with(jid).and_return(xmpp)
     expect(xmpp).to receive(:connect)
     expect(xmpp).to receive(:auth).with('123456')
 
-    presence = double("presence")
+    presence = double('presence')
     now = Time.now
     allow(Time).to receive(:now).and_return(now)
     expect(Jabber::Presence).to receive(:new).and_return(presence)
     expect(presence).to receive(:set_status).with("Uniform Notifier started on #{now}").and_return(presence)
     expect(xmpp).to receive(:send).with(presence)
 
-    message = double("message")
+    message = double('message')
     expect(Jabber::Message).to receive(:new).with('to@gmail.com', 'notify xmpp').and_return(message)
     expect(message).to receive(:set_type).with(:normal).and_return(message)
     expect(message).to receive(:set_subject).with('Uniform Notifier').and_return(message)
     expect(xmpp).to receive(:send).with(message)
 
-    UniformNotifier.xmpp = {:account => 'from@gmail.com', :password => '123456', :receiver => 'to@gmail.com', :show_online_status => true}
-    UniformNotifier::Xmpp.out_of_channel_notify(:title => 'notify xmpp')
+    UniformNotifier.xmpp = { account: 'from@gmail.com', password: '123456', receiver: 'to@gmail.com', show_online_status: true }
+    UniformNotifier::Xmpp.out_of_channel_notify(title: 'notify xmpp')
   end
 end