uniform_notifier 1.11.0 → 1.13.2

data/spec/spec_helper.rb

@@ -1,7 +1,9 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+# frozen_string_literal: true
 
-require "uniform_notifier"
-require "ruby-growl"
-require "xmpp4r"
-require "slack-notifier"
-require "rspec"
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'uniform_notifier'
+require 'ruby-growl'
+require 'xmpp4r'
+require 'slack-notifier'
+require 'rspec'

data/spec/uniform_notifier/airbrake_spec.rb

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

data/spec/uniform_notifier/base_spec.rb

@@ -1,22 +1,20 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe UniformNotifier::Base do
-  context "#inline_channel_notify" do
-    before do
-      allow(UniformNotifier::Base).to receive(:active?).and_return(true)
-    end
-    it "should keep the compatibility" do
-      expect(UniformNotifier::Base).to receive(:_inline_notify).once.with(:title => "something")
-      UniformNotifier::Base.inline_notify("something")
+  context '#inline_channel_notify' do
+    before { allow(UniformNotifier::Base).to receive(:active?).and_return(true) }
+    it 'should keep the compatibility' do
+      expect(UniformNotifier::Base).to receive(:_inline_notify).once.with(title: 'something')
+      UniformNotifier::Base.inline_notify('something')
     end
   end
-  context "#out_of_channel_notify" do
-    before do
-      allow(UniformNotifier::Base).to receive(:active?).and_return(true)
-    end
-    it "should keep the compatibility" do
-      expect(UniformNotifier::Base).to receive(:_out_of_channel_notify).once.with(:title => "something")
-      UniformNotifier::Base.out_of_channel_notify("something")
+  context '#out_of_channel_notify' do
+    before { allow(UniformNotifier::Base).to receive(:active?).and_return(true) }
+    it 'should keep the compatibility' do
+      expect(UniformNotifier::Base).to receive(:_out_of_channel_notify).once.with(title: 'something')
+      UniformNotifier::Base.out_of_channel_notify('something')
     end
   end
 end

data/spec/uniform_notifier/bugsnag_spec.rb

@@ -1,4 +1,6 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 class Bugsnag
   # mock Bugsnag
@@ -6,51 +8,63 @@ end
 
 RSpec.describe UniformNotifier::BugsnagNotifier do
   let(:notification_data) { {} }
-  it "should not notify bugsnag" do
+  it 'should not notify bugsnag' do
     expect(Bugsnag).not_to receive(:notify)
     UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
   end
-  context "with string notification" do
-    let(:notification_data) { {:user => 'user', :title => 'notify bugsnag', :url => 'URL', body: 'something'} }
+  context 'with string notification' do
+    let(:notification_data) { { user: 'user', title: 'notify bugsnag', url: 'URL', body: 'something' } }
 
-    it "should notify bugsnag" do
-      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new(notification_data[:title]), :grouping_hash => notification_data[:body], :notification => notification_data)
+    it 'should notify bugsnag' do
+      expect(Bugsnag).to receive(:notify).with(
+        UniformNotifier::Exception.new(notification_data[:title]),
+        grouping_hash: notification_data[:body], notification: notification_data
+      )
 
       UniformNotifier.bugsnag = true
       UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
     end
 
-    it "should notify bugsnag with option" do
-      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new(notification_data[:title]), :foo => :bar, :grouping_hash => notification_data[:body], :notification => notification_data)
+    it 'should notify bugsnag with option' do
+      expect(Bugsnag).to receive(:notify).with(
+        UniformNotifier::Exception.new(notification_data[:title]),
+        foo: :bar, grouping_hash: notification_data[:body], notification: notification_data
+      )
 
-      UniformNotifier.bugsnag = { :foo => :bar }
+      UniformNotifier.bugsnag = { foo: :bar }
       UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
     end
   end
-  context "with hash notification" do
-    let(:notification_data) { "notify bugsnag" }
+  context 'with hash notification' do
+    let(:notification_data) { 'notify bugsnag' }
 
-    it "should notify bugsnag" do
-      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new("notify bugsnag"), :grouping_hash => "notify bugsnag", :notification => {:title => "notify bugsnag"})
+    it 'should notify bugsnag' do
+      expect(Bugsnag).to receive(:notify).with(
+        UniformNotifier::Exception.new('notify bugsnag'),
+        grouping_hash: 'notify bugsnag', notification: { title: 'notify bugsnag' }
+      )
 
       UniformNotifier.bugsnag = true
       UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
     end
 
-    it "should notify bugsnag with option" do
-      expect(Bugsnag).to receive(:notify).with(UniformNotifier::Exception.new("notify bugsnag"), :foo => :bar, :grouping_hash => "notify bugsnag", :notification => {:title => "notify bugsnag"})
+    it 'should notify bugsnag with option' do
+      expect(Bugsnag).to receive(:notify).with(
+        UniformNotifier::Exception.new('notify bugsnag'),
+        foo: :bar, grouping_hash: 'notify bugsnag', notification: { title: 'notify bugsnag' }
+      )
 
-      UniformNotifier.bugsnag = { :foo => :bar }
+      UniformNotifier.bugsnag = { foo: :bar }
       UniformNotifier::BugsnagNotifier.out_of_channel_notify(notification_data)
     end
   end
 
-  it "should notify bugsnag with correct backtrace" do
+  it 'should notify bugsnag with correct backtrace' do
     expect(Bugsnag).to receive(:notify) do |error|
       expect(error).to be_a UniformNotifier::Exception
-      expect(error.backtrace).to eq ["bugsnag spec test"]
+      expect(error.backtrace).to eq ['bugsnag spec test']
     end
     UniformNotifier.bugsnag = true
-    UniformNotifier::BugsnagNotifier.out_of_channel_notify(backtrace: ["bugsnag spec test"])
+    UniformNotifier::BugsnagNotifier.out_of_channel_notify(backtrace: ['bugsnag spec test'])
   end
 end

data/spec/uniform_notifier/customized_logger_spec.rb

@@ -1,21 +1,23 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 RSpec.describe UniformNotifier::CustomizedLogger do
-  it "should not notify to customized logger" do
-    expect(UniformNotifier::CustomizedLogger.out_of_channel_notify(:title => "notify rails logger")).to be_nil
+  it 'should not notify to customized logger' do
+    expect(UniformNotifier::CustomizedLogger.out_of_channel_notify(title: 'notify rails logger')).to be_nil
   end
 
-  it "should notify to customized logger" do
-    logger = File.open( 'test.log', 'a+' )
+  it 'should notify to customized logger' do
+    logger = File.open('test.log', 'a+')
     logger.sync = true
 
     now = Time.now
     allow(Time).to receive(:now).and_return(now)
     UniformNotifier.customized_logger = logger
-    UniformNotifier::CustomizedLogger.out_of_channel_notify(:title => "notify rails logger")
+    UniformNotifier::CustomizedLogger.out_of_channel_notify(title: 'notify rails logger')
 
     logger.seek(0)
-    expect(logger.read).to eq "#{now.strftime("%Y-%m-%d %H:%M:%S")}[WARN] notify rails logger"
+    expect(logger.read).to eq "#{now.strftime('%Y-%m-%d %H:%M:%S')}[WARN] notify rails logger"
 
     File.delete('test.log')
   end

data/spec/uniform_notifier/growl_spec.rb

@@ -1,56 +1,74 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe UniformNotifier::Growl do
-
-  it "should not notify growl" do
-    expect(UniformNotifier::Growl.out_of_channel_notify(:title => 'notify growl')).to be_nil
+  it 'should not notify growl' do
+    expect(UniformNotifier::Growl.out_of_channel_notify(title: 'notify growl')).to be_nil
   end
 
-  it "should notify growl without password" do
-    growl = double('growl', :is_a? => true)
+  it 'should notify growl without password' do
+    growl = double('growl', is_a?: true)
     expect(Growl).to receive(:new).with('localhost', 'uniform_notifier').and_return(growl)
     expect(growl).to receive(:add_notification).with('uniform_notifier')
     expect(growl).to receive(:password=).with(nil)
-    expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'Uniform Notifier Growl has been turned on').ordered
-    expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl without password').ordered
+    expect(growl).to receive(:notify).with(
+      'uniform_notifier',
+      'Uniform Notifier',
+      'Uniform Notifier Growl has been turned on'
+    ).ordered
+    expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl without password')
+      .ordered
 
     UniformNotifier.growl = true
-    UniformNotifier::Growl.out_of_channel_notify(:title => 'notify growl without password')
+    UniformNotifier::Growl.out_of_channel_notify(title: 'notify growl without password')
   end
 
-  it "should notify growl with password" do
-    growl = double('growl', :is_a? => true)
+  it 'should notify growl with password' do
+    growl = double('growl', is_a?: true)
     expect(Growl).to receive(:new).with('localhost', 'uniform_notifier').and_return(growl)
     expect(growl).to receive(:add_notification).with('uniform_notifier')
     expect(growl).to receive(:password=).with('123456')
-    expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'Uniform Notifier Growl has been turned on').ordered
+    expect(growl).to receive(:notify).with(
+      'uniform_notifier',
+      'Uniform Notifier',
+      'Uniform Notifier Growl has been turned on'
+    ).ordered
     expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl with password').ordered
 
-    UniformNotifier.growl = { :password => '123456' }
-    UniformNotifier::Growl.out_of_channel_notify(:title => 'notify growl with password')
+    UniformNotifier.growl = { password: '123456' }
+    UniformNotifier::Growl.out_of_channel_notify(title: 'notify growl with password')
   end
 
-  it "should notify growl with host" do
-    growl = double('growl', :is_a? => true)
+  it 'should notify growl with host' do
+    growl = double('growl', is_a?: true)
     expect(Growl).to receive(:new).with('10.10.156.17', 'uniform_notifier').and_return(growl)
     expect(growl).to receive(:add_notification).with('uniform_notifier')
     expect(growl).to receive(:password=).with('123456')
-    expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'Uniform Notifier Growl has been turned on').ordered
+    expect(growl).to receive(:notify).with(
+      'uniform_notifier',
+      'Uniform Notifier',
+      'Uniform Notifier Growl has been turned on'
+    ).ordered
     expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl with password').ordered
 
-    UniformNotifier.growl = { :password => '123456', :host => '10.10.156.17' }
-    UniformNotifier::Growl.out_of_channel_notify(:title => 'notify growl with password')
+    UniformNotifier.growl = { password: '123456', host: '10.10.156.17' }
+    UniformNotifier::Growl.out_of_channel_notify(title: 'notify growl with password')
   end
 
-  it "should notify growl with quiet" do
-    growl = double('growl', :is_a? => true)
+  it 'should notify growl with quiet' do
+    growl = double('growl', is_a?: true)
     expect(Growl).to receive(:new).with('localhost', 'uniform_notifier').and_return(growl)
     expect(growl).to receive(:add_notification).with('uniform_notifier')
     expect(growl).to receive(:password=).with('123456')
-    expect(growl).not_to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'Uniform Notifier Growl has been turned on')
+    expect(growl).not_to receive(:notify).with(
+      'uniform_notifier',
+      'Uniform Notifier',
+      'Uniform Notifier Growl has been turned on'
+    )
     expect(growl).to receive(:notify).with('uniform_notifier', 'Uniform Notifier', 'notify growl with password')
 
-    UniformNotifier.growl = { :password => '123456', :quiet => true }
-    UniformNotifier::Growl.out_of_channel_notify(:title => 'notify growl with password')
+    UniformNotifier.growl = { password: '123456', quiet: true }
+    UniformNotifier::Growl.out_of_channel_notify(title: 'notify growl with password')
   end
 end

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