slack_log_device 4.0.1 → 4.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 72581be793e8126c5edc0618a27638f5a6de5f6f
-  data.tar.gz: ed4c06d973fe0d78360a3fcb45c888b65b5f5e57
+  metadata.gz: fa496f8eaaa923412893876e4dc044c26d2d0064
+  data.tar.gz: b8fe6470d8864cd83fb17e462bdc59e0e75b4596
 SHA512:
-  metadata.gz: bbebab53db046820e98273a52a69ca46f3aab5e97595263b38e07eb1ee01b490a4659c7009d3964e911a44d4064ada9feb8b1674bebd44419039e71a5f5ddf69
-  data.tar.gz: e926f6f68041fcfdd395052066b26bf3746456f3f88dd12db7926b7784cd3f3bfa529e692a1b9c3831dd01803de07ebfa27ed6958572d8f9ff2b3d9b453c9de2
+  metadata.gz: 6c675155309e06685fb1ea2e83f81d8f3ec563b503f2b132ddf6070c7bc8c05a5dc96732afadf3cdb3569c1da50204a8fd9256c6554e4c4812a6227071986f9b
+  data.tar.gz: d4b68b6993c883600e93ea8d67c7751af7dd854f549badfd9949d2048efd9911db9ea417e52045887449c35ed55c06a6645912d06e74edf7f368a20595ab5bb5

data/VERSION

@@ -1 +1 @@
-4.0.1
+4.0.2

data/lib/slack_log_device.rb

@@ -30,7 +30,7 @@ class SlackLogDevice
     self.timeout = options.key?(:timeout) ? options[:timeout] : 5
     self.username = options[:username]
     self.webhook_url = options[:webhook_url]
-    at_exit { flush }
+    at_exit { flush } unless Thread.current.key?(:__rspec)
   end
 
   def auto_flush?

data/lib/slack_log_device/formatter.rb

@@ -9,7 +9,7 @@ class SlackLogDevice
     def initialize(options = {}, &block)
       options.assert_valid_keys(:extra_metadata)
       @extra_metadata = options.key?(:extra_metadata) ? options[:extra_metadata] : {}
-      @message_conveter = block_given? ? Proc.new(&block) : -> (message) { message }
+      @message_converter = block_given? ? Proc.new(&block) : -> (message) { message }
     end
 
     def call(severity, datetime, progname, message)
@@ -44,7 +44,7 @@ class SlackLogDevice
     end
 
     def convert_message(message)
-      @message_conveter.call(message.to_s.strip).to_s.strip
+      @message_converter.call(message.to_s.strip).to_s.strip
     end
 
     def default_metadata(request)

data/slack_log_device.gemspec

@@ -9,8 +9,7 @@ Gem::Specification.new do |s|
   s.description = 'LogDevice implementation that post logs on a Slack channel'
   s.license = 'MIT'
 
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.files = `git ls-files | grep -vE '^(spec/|test/|\\.|Gemfile|Rakefile)'`.split("\n")
   s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slack_log_device
 version: !ruby/object:Gem::Version
-  version: 4.0.1
+  version: 4.0.2
 platform: ruby
 authors:
 - Alexis Toulotte
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-27 00:00:00.000000000 Z
+date: 2017-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -116,21 +116,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- Gemfile
 - MIT-LICENSE
 - README.mdown
-- Rakefile
 - VERSION
 - lib/slack_log_device.rb
 - lib/slack_log_device/debug_exceptions.rb
 - lib/slack_log_device/formatter.rb
 - lib/slack_log_device/set_request_in_thread.rb
 - slack_log_device.gemspec
-- spec/slack_log_device/formatter_spec.rb
-- spec/slack_log_device_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/alexistoulotte/slack_log_device
 licenses:
 - MIT
@@ -155,7 +148,4 @@ rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
 summary: LogDevice for Slack
-test_files:
-- spec/slack_log_device/formatter_spec.rb
-- spec/slack_log_device_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/.gitignore

@@ -1,6 +0,0 @@
-.DS_Store
-/.bundle/
-/.byebug_history
-/.ruby-version
-/Gemfile.lock
-/pkg/

data/.rspec

@@ -1,2 +0,0 @@
---colour
---order random

data/Gemfile

@@ -1,3 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec

data/Rakefile

@@ -1,10 +0,0 @@
-require 'bundler'
-require 'rspec/core/rake_task'
-
-Bundler::GemHelper.install_tasks
-
-desc 'Default: runs specs.'
-task default: :spec
-
-desc 'Run all specs in spec directory.'
-RSpec::Core::RakeTask.new(:spec)

data/spec/slack_log_device/formatter_spec.rb

@@ -1,285 +0,0 @@
-require 'spec_helper'
-
-describe SlackLogDevice::Formatter do
-
-  let(:max_message_length) { SlackLogDevice::Formatter::MAX_MESSAGE_LENGTH }
-
-  describe '::MAX_MESSAGE_LENGTH' do
-
-    it 'is 4000' do
-      expect(SlackLogDevice::Formatter::MAX_MESSAGE_LENGTH).to be(4000)
-    end
-
-  end
-
-  describe '#call' do
-
-    context "with no block or metadata" do
-
-      let(:formatter) { SlackLogDevice::Formatter.new }
-
-      it 'returns a formatted message' do
-        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq('*`DEBUG`*: Hello World')
-      end
-
-      it 'message is stripped' do
-        expect(formatter.call('DEBUG', Time.now, ' ', " \nHello World   ")).to eq('*`DEBUG`*: Hello World')
-      end
-
-      it 'message is converted to string' do
-        expect(formatter.call('DEBUG', Time.now, ' ', 42)).to eq('*`DEBUG`*: 42')
-      end
-
-      it 'includes progname if given' do
-        expect(formatter.call('DEBUG', Time.now, 'My App', 'Hello World')).to eq('*`DEBUG`* (*My App*): Hello World')
-      end
-
-      it 'formats exception' do
-        exception = RuntimeError.new('BAM!')
-        exception.set_backtrace(['foo', 'bar'])
-        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred: BAM!\n\n```foo\nbar```")
-      end
-
-      it 'formats exception with no message' do
-        exception = RuntimeError.new(' ')
-        exception.set_backtrace(['foo', 'bar'])
-        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred:\n\n```foo\nbar```")
-      end
-
-      it 'formats exception with no backtrace' do
-        exception = RuntimeError.new('BAM!')
-        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred: BAM!")
-      end
-
-      it 'strips exception message' do
-        exception = RuntimeError.new("  BAM!   \n")
-        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred: BAM!")
-      end
-
-      it 'message never exceed 4000 chars (without exception)' do
-        message = formatter.call('DEBUG', Time.now, nil, 'Bam' * (max_message_length / 2))
-        expect(message.size).to eq(max_message_length)
-        expect(message).to end_with('BamBa...')
-      end
-
-      it 'message never exceed 4000 chars (with exception)' do
-        exception = RuntimeError.new('BAM!')
-        exception.set_backtrace(['a' * (max_message_length - 49)])
-        message = formatter.call('DEBUG', Time.now, nil, exception)
-        expect(message.size).to eq(max_message_length)
-        expect(message).to end_with("aaaaaa...```")
-      end
-
-      it 'can be exactly 4000 chars with trace (without three dots)' do
-        exception = RuntimeError.new('BAM!')
-        exception.set_backtrace(['a' * (max_message_length - 50)])
-        message = formatter.call('DEBUG', Time.now, nil, exception)
-        expect(message.size).to eq(max_message_length)
-        expect(message).to end_with('a```')
-      end
-
-      it 'does not add three dots if less than 4000' do
-        exception = RuntimeError.new('BAM!')
-        exception.set_backtrace(['a' * (max_message_length - 51)])
-        message = formatter.call('DEBUG', Time.now, nil, exception)
-        expect(message.size).to eq(max_message_length - 1)
-        expect(message).to end_with('a```')
-      end
-
-      it 'does not format backtrace if message is too long' do
-        exception = RuntimeError.new('BAM!' * max_message_length)
-        exception.set_backtrace(['hello world'])
-        message = formatter.call('DEBUG', Time.now, nil, exception)
-        expect(message.size).to eq(max_message_length)
-        expect(message).not_to include('hello')
-        expect(message).not_to include('```')
-      end
-
-      it 'message does not exceed 4000 if there is no backtrace' do
-        exception = RuntimeError.new('BAM!' * max_message_length)
-        message = formatter.call('DEBUG', Time.now, nil, exception)
-        expect(message.size).to eq(max_message_length)
-      end
-
-      it 'does not formats a blank backtrace (due to large message)' do
-        exception = RuntimeError.new('a' * (max_message_length - 46))
-        exception.set_backtrace(['hello world'])
-        message = formatter.call('DEBUG', Time.now, nil, exception)
-        expect(message.size).to eq(max_message_length - 8)
-        expect(message).not_to include('```')
-        expect(message).to end_with('a')
-      end
-
-      it 'can format a backtrace with just one char' do
-        exception = RuntimeError.new('a' * (max_message_length - 47))
-        exception.set_backtrace(['hello world'])
-        message = formatter.call('DEBUG', Time.now, nil, exception)
-        expect(message.size).to eq(max_message_length)
-        expect(message).to end_with("aaa\n\n```h```")
-      end
-
-      it 'can format a backtrace with just one char and three dots' do
-        exception = RuntimeError.new('a' * (max_message_length - 50))
-        exception.set_backtrace(['hello world'])
-        message = formatter.call('DEBUG', Time.now, nil, exception)
-        expect(message.size).to eq(max_message_length)
-        expect(message).to end_with("aaa\n\n```h...```")
-      end
-
-    end
-
-    context 'if a block is given' do
-
-      let(:formatter) { SlackLogDevice::Formatter.new { |message| "#{message.reverse} Hey hoy" } }
-
-      it 'returns formatter message with block invoked' do
-        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq("*`DEBUG`*: dlroW olleH Hey hoy")
-      end
-
-      it 'invokes block with stripped message' do
-        expect(formatter.call('DEBUG', Time.now, ' ', "    Hello World  \t")).to eq("*`DEBUG`*: dlroW olleH Hey hoy")
-      end
-
-      it 'does not append block message if blank' do
-        formatter = SlackLogDevice.formatter { '   ' }
-        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq('*`DEBUG`*:')
-      end
-
-      it 'converts block value to string' do
-        formatter = SlackLogDevice.formatter { 42 }
-        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq('*`DEBUG`*: 42')
-      end
-
-      it 'is correct if block returns nil' do
-        formatter = SlackLogDevice.formatter { nil }
-        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq('*`DEBUG`*:')
-      end
-
-      it 'strips block return value' do
-        formatter = SlackLogDevice.formatter { "  hey \n" }
-        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq('*`DEBUG`*: hey')
-      end
-
-      it 'includes progname if given' do
-        expect(formatter.call('DEBUG', Time.now, 'MyApp', 'Hello World')).to eq("*`DEBUG`* (*MyApp*): dlroW olleH Hey hoy")
-      end
-
-      it 'formats exception' do
-        exception = RuntimeError.new('BAM!')
-        exception.set_backtrace(['foo', 'bar'])
-        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred: !MAB Hey hoy\n\n```foo\nbar```")
-      end
-
-      it 'is correct with exception if block returns a blank message' do
-        formatter = SlackLogDevice.formatter { '    ' }
-        exception = RuntimeError.new('BAM!')
-        exception.set_backtrace(['foo', 'bar'])
-        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred:\n\n```foo\nbar```")
-      end
-
-      it 'message never exceed 4000 chars (without exception)' do
-        message = formatter.call('DEBUG', Time.now, ' ', 'Hello World' * (max_message_length / 3))
-        expect(message.size).to eq(max_message_length)
-        expect(message).to end_with('olleHdlro...')
-      end
-
-      it 'message never exceed 4000 chars (with exception)' do
-        exception = RuntimeError.new('BAM!')
-        exception.set_backtrace(['a' * max_message_length])
-        message = formatter.call('DEBUG', Time.now, 'My App', exception)
-        expect(message.size).to eq(max_message_length)
-        expect(message).to end_with("aaaaaa...```")
-      end
-
-    end
-
-    context 'with extra metadata' do
-
-      let(:extra_metadata) {{
-        'User ' => "   `#{user}` ",
-        '  Reversed user' => -> (options) { user.reverse },
-      }}
-      let(:formatter) { SlackLogDevice::Formatter.new(extra_metadata: extra_metadata) }
-      let(:user) { 'John' }
-
-      it 'returns a message formatted' do
-        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq("*`DEBUG`*: Hello World\n\n• *User*: `John`\n• *Reversed user*: nhoJ")
-      end
-
-      it 'returns a message formatted (with exception)' do
-        exception = RuntimeError.new('BAM!')
-        exception.set_backtrace(['a', 'b'])
-        message = formatter.call('DEBUG', Time.now, 'My App', exception)
-        expect(message).to eq("*`DEBUG`* (*My App*): A `RuntimeError` occurred: BAM!\n\n• *User*: `John`\n• *Reversed user*: nhoJ\n\n```a\nb```")
-      end
-
-      it 'extra metadata are not added if message is too long' do
-        expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World' * max_message_length)).not_to include('•')
-      end
-
-      it 'extra metadata are not added if message is too long (with exception)' do
-        exception = RuntimeError.new('BAM!' * max_message_length)
-        exception.set_backtrace(['a'])
-        message = formatter.call('DEBUG', Time.now, 'My App', exception)
-        expect(message).not_to include('•')
-      end
-
-      it 'blocks of extra metadata is invoked with options containing exception' do
-        extra_metadata['Exception class'] = -> (options) { options[:exception].class.name }
-        exception = RuntimeError.new('BAM!')
-        expect(formatter.call('DEBUG', Time.now, nil, exception)).to include('• *Exception class*: RuntimeError')
-      end
-
-      it 'blocks of extra metadata does not add exception option if not present' do
-        extra_metadata['Exception?'] = -> (options) { options.key?(:exception) ? 'Yes' : 'No' }
-        expect(formatter.call('DEBUG', Time.now, nil, 'Hello World')).to include("• *Exception?*: No")
-      end
-
-    end
-
-    context 'with request set in current thread' do
-
-      let(:exception) { RuntimeError.new('BAM!') }
-      let(:formatter) { SlackLogDevice::Formatter.new }
-      let(:request) { double(remote_addr: '127.0.0.1', user_agent: 'Mozilla', method: 'GET', url: 'http://google.com') }
-
-      before :each do
-        Thread.current[:slack_log_device_request] = request
-      end
-
-      after :each do
-        Thread.current[:slack_log_device_request] = nil
-      end
-
-      it 'logs metadata' do
-        expect(formatter.call('DEBUG', Time.now, nil, exception)).to eq("*`DEBUG`*: A `RuntimeError` occurred: BAM!\n\n• *Method*: `GET`\n• *URL*: `http://google.com`\n• *Remote address*: `127.0.0.1`\n• *User-Agent*: `Mozilla`")
-      end
-
-    end
-
-  end
-
-  describe '#extra_metadata' do
-
-    it 'is an empty hash by default' do
-      expect(SlackLogDevice::Formatter.new.extra_metadata).to eq({})
-    end
-
-    it 'can be specified at constructor' do
-      formatter = SlackLogDevice::Formatter.new(extra_metadata: { 'Bar' => 'foo' })
-      expect(formatter.extra_metadata).to eq({ 'Bar' => 'foo' })
-    end
-
-  end
-
-  describe '#initialize' do
-
-    it 'raise an error if an invalid option is given' do
-      expect {
-        SlackLogDevice::Formatter.new(foo: 'bar')
-      }.to raise_error(ArgumentError, 'Unknown key: :foo. Valid keys are: :extra_metadata')
-    end
-
-  end
-
-end

data/spec/slack_log_device_spec.rb

@@ -1,553 +0,0 @@
-require 'spec_helper'
-
-describe SlackLogDevice do
-
-  let(:device) { SlackLogDevice.new(options) }
-  let(:options) { { username: 'MyApp', webhook_url: 'https://hooks.slack.com/services/test' } }
-
-  before :each do
-    allow(HTTParty).to receive(:post)
-  end
-
-  it 'is not a LogDevice instance' do
-    expect(device).not_to be_a(Logger::LogDevice)
-  end
-
-  describe '.formatter' do
-
-    it 'returns a SlackLogDevice::Formatter' do
-      expect(SlackLogDevice.formatter).to be_a(SlackLogDevice::Formatter)
-    end
-
-    it 'block is given to formatter constructor' do
-      formatter = SlackLogDevice.formatter { |message| message.reverse }
-      expect(formatter.call('DEBUG', Time.now, ' ', 'Hello World')).to eq("*`DEBUG`*: dlroW olleH")
-    end
-
-    it 'options are forwarded to formatter constructor' do
-      formatter = SlackLogDevice.formatter(extra_metadata: { 'bar' => 'foo' })
-      expect(formatter.extra_metadata).to eq({ 'bar' => 'foo' })
-    end
-
-  end
-
-  describe '#auto_flush?' do
-
-    it 'is false by default' do
-      options.delete(:auto_flush)
-      expect(device).not_to be_auto_flush
-    end
-
-    it 'can be set to true' do
-      options[:auto_flush] = true
-      expect(device).to be_auto_flush
-    end
-
-  end
-
-  describe '#close' do
-
-    it 'does nothing' do
-      expect {
-        device.close
-      }.not_to raise_error
-    end
-
-  end
-
-  describe '#channel' do
-
-    it 'is null by default' do
-      options.delete(:channel)
-      expect(device.channel).to be_nil
-    end
-
-    it 'is nil if blank' do
-      options[:channel] = "  \n"
-      expect(device.channel).to be_nil
-    end
-
-    it 'can be set' do
-      expect {
-        device.channel = '#foo-bar_42abc'
-      }.to change { device.channel  }.from(nil).to('#foo-bar_42abc')
-    end
-
-    it 'raise an error if it contains spaces' do
-      expect {
-        device.channel = '#foo bar'
-      }.to raise_error(ArgumentError, 'Invalid channel specified: "#foo bar", it must start with # or @ and be in lower case with no spaces or special chars and its length must not exceed 22 chars')
-    end
-
-    it 'raise an error if it contains more than 22 chars (including #)' do
-      expect {
-        device.channel = "##{'a' * 22}"
-      }.to raise_error(ArgumentError)
-      device.channel = "##{'a' * 21}" # ok
-    end
-
-    it 'raise an error if it contains upper case letters' do
-      expect {
-        device.channel = '#Foo'
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'raise an error if it contains special chars' do
-      expect {
-        device.channel = '#f{oo'
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'raise an error if it does not start with a # or @' do
-      expect {
-        device.channel = 'foo'
-      }.to raise_error(ArgumentError)
-      device.channel = '#foo' # ok
-      device.channel = '@foo' # ok
-    end
-
-    it 'raise an error if it only contains prefix' do
-      expect {
-        device.channel = '#'
-      }.to raise_error(ArgumentError)
-    end
-
-  end
-
-  describe '#flush' do
-
-    it 'sends a post to webhook URL with given given message and specified username' do
-      device.write('BAM!')
-      expect(HTTParty).to receive(:post).with(options[:webhook_url], body: { 'text' => 'BAM!', 'username' => options[:username] }.to_json, headers: { 'Content-Type' => 'application/json' }, timeout: 5)
-      device.flush
-    end
-
-    it 'does not send username if nil' do
-      options.delete(:username)
-      device.write('BAM!')
-      expect(HTTParty).to receive(:post).with(options[:webhook_url], body: { 'text' => 'BAM!' }.to_json, headers: { 'Content-Type' => 'application/json' }, timeout: 5)
-      device.flush
-    end
-
-    it 'use specified channel' do
-      options[:channel] = '#foo'
-      device.write('BAM!')
-      expect(HTTParty).to receive(:post).with(options[:webhook_url], body: { 'text' => 'BAM!', 'channel' => '#foo', 'username' => options[:username] }.to_json, headers: { 'Content-Type' => 'application/json' }, timeout: 5)
-      device.flush
-    end
-
-    it 'use specified timeout' do
-      options[:timeout] = 12
-      device.write('BAM!')
-      expect(HTTParty).to receive(:post).with(options[:webhook_url], body: { 'text' => 'BAM!', 'username' => options[:username] }.to_json, headers: { 'Content-Type' => 'application/json' }, timeout: 12)
-      device.flush
-    end
-
-    it 'flushes all message writen separated by a new line' do
-      device.write('BAM!')
-      device.write('BIM!')
-      expect(HTTParty).to receive(:post).twice
-      device.flush
-    end
-
-    it 'returns nil' do
-      device.write('BIM!')
-      expect(device.flush).to be_nil
-    end
-
-    it 'clears buffer' do
-      device.write('BAM!')
-      device.write('BIM!')
-      expect {
-        device.flush
-      }.to change { device.instance_variable_get(:@buffer) }.to([])
-      expect(HTTParty).not_to receive(:post)
-      device.flush
-    end
-
-  end
-
-  describe '#flush?' do
-
-    it 'is true if max_buffer_size is reached' do
-      options[:max_buffer_size] = 2
-      device.write('hello')
-      device.write('world')
-      expect {
-        device.instance_variable_get(:@buffer).send(:<<, 'foo')
-      }.to change { device.flush? }.from(false).to(true)
-    end
-
-    it 'is true if auto_flush option is present' do
-      expect {
-        device.auto_flush = true
-      }.to change { device.flush? }.from(false).to(true)
-    end
-
-    it 'is true if flush delay is 0' do
-      expect {
-        device.flush_delay = 0
-      }.to change { device.flush? }.from(false).to(true)
-    end
-
-  end
-
-  describe '#flush_delay' do
-
-    it 'is 1 by default' do
-      expect(device.flush_delay).to eq(1)
-    end
-
-    it 'can be specified' do
-      options[:flush_delay] = 10
-      expect(device.flush_delay).to be(10)
-    end
-
-    it 'raise an error if invalid' do
-      options[:flush_delay] = 'foo'
-      expect {
-        device
-      }.to raise_error(ArgumentError, 'Invalid flush delay: "foo"')
-    end
-
-    it 'raise an error if negative' do
-      options[:flush_delay] = -1
-      expect {
-        device
-      }.to raise_error(ArgumentError, 'Invalid flush delay: -1')
-    end
-
-    it 'can be zero' do
-      options[:flush_delay] = 0
-      expect(device.flush_delay).to be(0)
-    end
-
-    it 'raise an error if blank' do
-      options[:flush_delay] = ' '
-      expect {
-        device
-      }.to raise_error(ArgumentError, 'Invalid flush delay: " "')
-    end
-
-    it 'raise an error if set as nil' do
-      expect {
-        device.flush_delay = nil
-      }.to raise_error(ArgumentError, 'Invalid flush delay: nil')
-    end
-
-    it 'can be specified as string' do
-      options[:flush_delay] = '42'
-      expect(device.flush_delay).to eq(42)
-    end
-
-    it 'can be set' do
-      expect {
-        device.flush_delay = 15
-      }.to change { device.flush_delay }.from(1).to(15)
-    end
-
-  end
-
-  describe '#initialize' do
-
-    it 'raise an error if an invalid option is given' do
-      expect {
-        SlackLogDevice.new(foo: 'bar')
-      }.to raise_error(ArgumentError, "Unknown key: :foo. Valid keys are: :auto_flush, :channel, :flush_delay, :max_buffer_size, :timeout, :username, :webhook_url")
-    end
-
-    it 'raise an error if webhook option is not given' do
-      expect {
-        SlackLogDevice.new(options.except(:webhook_url))
-      }.to raise_error(ArgumentError, 'Webhook URL must be specified')
-    end
-
-  end
-
-  describe '#max_buffer_size' do
-
-    it 'is 10 by default' do
-      expect(device.max_buffer_size).to eq(10)
-    end
-
-    it 'can be specified' do
-      options[:max_buffer_size] = 42
-      expect(device.max_buffer_size).to be(42)
-    end
-
-    it 'raise an error if invalid' do
-      options[:max_buffer_size] = 'foo'
-      expect {
-        device
-      }.to raise_error(ArgumentError, 'Invalid max buffer size: "foo"')
-    end
-
-    it 'raise an error if negative' do
-      options[:max_buffer_size] = -1
-      expect {
-        device
-      }.to raise_error(ArgumentError, 'Invalid max buffer size: -1')
-    end
-
-    it 'can be zero' do
-      options[:max_buffer_size] = 0
-      expect(device.max_buffer_size).to be_zero
-    end
-
-    it 'raise an error if blank' do
-      options[:max_buffer_size] = ' '
-      expect {
-        device
-      }.to raise_error(ArgumentError, 'Invalid max buffer size: " "')
-    end
-
-    it 'raise an error if set as nil' do
-      expect {
-        device.max_buffer_size = nil
-      }.to raise_error(ArgumentError, 'Invalid max buffer size: nil')
-    end
-
-    it 'can be specified as string' do
-      options[:max_buffer_size] = '42'
-      expect(device.max_buffer_size).to eq(42)
-    end
-
-    it 'can be set' do
-      expect {
-        device.max_buffer_size = 42
-      }.to change { device.max_buffer_size }.from(10).to(42)
-    end
-
-  end
-
-  describe '#timeout' do
-
-    it 'is 5 by default' do
-      expect(device.timeout).to eq(5)
-    end
-
-    it 'can be specified' do
-      options[:timeout] = 10
-      expect(device.timeout).to be(10)
-    end
-
-    it 'raise an error if invalid' do
-      options[:timeout] = 'foo'
-      expect {
-        device
-      }.to raise_error(ArgumentError, 'Invalid timeout: "foo"')
-    end
-
-    it 'raise an error if negative' do
-      options[:timeout] = -1
-      expect {
-        device
-      }.to raise_error(ArgumentError, 'Invalid timeout: -1')
-    end
-
-    it 'raise an error if zero' do
-      options[:timeout] = 0
-      expect {
-        device
-      }.to raise_error(ArgumentError, 'Invalid timeout: 0')
-    end
-
-    it 'raise an error if blank' do
-      options[:timeout] = ' '
-      expect {
-        device
-      }.to raise_error(ArgumentError, 'Invalid timeout: " "')
-    end
-
-    it 'raise an error if set as nil' do
-      expect {
-        device.timeout = nil
-      }.to raise_error(ArgumentError, 'Invalid timeout: nil')
-    end
-
-    it 'can be specified as string' do
-      options[:timeout] = '42'
-      expect(device.timeout).to eq(42)
-    end
-
-    it 'can be set' do
-      expect {
-        device.timeout = 15
-      }.to change { device.timeout }.from(5).to(15)
-    end
-
-  end
-
-  describe '#username' do
-
-    it 'is username set at initialization' do
-      expect(device.username).to eq('MyApp')
-    end
-
-    it 'is nil if not specified' do
-      device = SlackLogDevice.new(options.except(:username))
-      expect(device.username).to be_nil
-    end
-
-    it 'is squished' do
-      options[:username] = "John   Doe\n "
-      expect(device.username).to eq('John Doe')
-    end
-
-    it 'is nil if blank' do
-      options[:username] = " \n"
-      expect(device.username).to be_nil
-    end
-
-    it 'can be set' do
-      expect {
-        device.username = 'John Doe'
-      }.to change { device.username }.from(options[:username]).to('John Doe')
-    end
-
-  end
-
-  describe '#webhook_url' do
-
-    it 'is webhook_url set at initialization' do
-      expect(device.webhook_url).to eq('https://hooks.slack.com/services/test')
-    end
-
-    it 'raise an error if invalid' do
-      options[:webhook_url] = 'foo'
-      expect {
-        device
-      }.to raise_error(ArgumentError, 'Invalid webhook URL: "foo"')
-    end
-
-    it 'can be an HTTP URL' do
-      options[:webhook_url] = 'http://google.com'
-      expect(device.webhook_url).to eq('http://google.com')
-    end
-
-    it 'can be an HTTPs URL' do
-      options[:webhook_url] = 'https://google.com'
-      expect(device.webhook_url).to eq('https://google.com')
-    end
-
-    it 'raise an error if not an HTTP(s) url' do
-      options[:webhook_url] = 'ftp://google.com'
-      expect {
-        device
-      }.to raise_error(ArgumentError, 'Invalid webhook URL: "ftp://google.com"')
-    end
-
-    it 'can be set' do
-      expect {
-        device.webhook_url = 'http://google.com'
-      }.to change { device.webhook_url }.from(options[:webhook_url]).to('http://google.com')
-    end
-
-  end
-
-  describe '#write' do
-
-    it 'returns nil' do
-      expect(device.write('BAM!')).to be_nil
-    end
-
-    it 'strips message' do
-      device.write("     BAM  !\n")
-      expect(device.instance_variable_get(:@buffer)).to eq(['BAM  !'])
-    end
-
-    it 'converts message to string' do
-      device.write(42)
-      expect(device.instance_variable_get(:@buffer)).to eq(['42'])
-    end
-
-    it 'adds given string to existing buffer with a two \n' do
-      device.write('BAM!')
-      expect {
-        device.write('BIM!')
-      }.to change { device.instance_variable_get(:@buffer) }.from(['BAM!']).to(['BAM!', 'BIM!'])
-    end
-
-    it 'does nothing if message is blank' do
-      expect(HTTParty).not_to receive(:post)
-      expect {
-        expect(device.write(" \n")).to be_nil
-      }.not_to change { device.instance_variable_get(:@buffer) }
-    end
-
-    it 'does nothing if message is nil' do
-      expect(HTTParty).not_to receive(:post)
-      expect(device.write(nil)).to be_nil
-      expect(device.instance_variable_get(:@buffer)).to eq([])
-    end
-
-    it 'does not post HTTP message if auto flush is false' do
-      expect(HTTParty).not_to receive(:post)
-      device.write('BAM!')
-    end
-
-  end
-
-  describe Logger, 'with slack log device' do
-
-    let(:logger) { Logger.new(device).tap { |logger| logger.level = Logger::INFO } }
-
-    it 'does nothing if log level is lower than specified one' do
-      expect(HTTParty).not_to receive(:post)
-      logger.debug('BIM!')
-      device.flush
-    end
-
-    it 'send HTTP request if log level is equal to specified one' do
-      expect(HTTParty).to receive(:post)
-      logger.info('BIM!')
-      device.flush
-    end
-
-    it 'send HTTP request if log level is higher to specified one' do
-      expect(HTTParty).to receive(:post)
-      logger.warn('BIM!')
-      device.flush
-    end
-
-    describe '#close' do
-
-      it 'does not raise any error' do
-        expect {
-          logger.close
-        }.not_to raise_error
-      end
-
-    end
-
-    describe '@logdev' do
-
-      let(:logdev) { logger.instance_variable_get(:@logdev) }
-
-      it 'is a LogDevice instance' do
-        expect(logdev).to be_a(Logger::LogDevice)
-      end
-
-      describe '#dev' do
-
-        let(:dev) { logdev.dev }
-
-        it 'is SlackLogDevice instance' do
-          expect(dev).to be(device)
-        end
-
-      end
-
-      describe '#filename' do
-
-        it 'is nil' do
-          expect(logdev.filename).to be_nil
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,6 +0,0 @@
-require File.expand_path("#{__dir__}/../lib/slack_log_device")
-require 'byebug'
-
-RSpec.configure do |config|
-  config.raise_errors_for_deprecations!
-end