harbinger 0.0.1.pre → 0.1.0

data/spec/controllers/harbinger/messages_controller_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_slow_helper'
+require 'harbinger/messages_controller'
+
+module Harbinger
+  describe MessagesController, type: :controller do
+    routes { Harbinger::Engine.routes }
+    render_views false
+    context 'GET :index' do
+      it 'searches the DatabaseChannelMessage' do
+        message_1, message_2 = double, double
+        allow(DatabaseChannelMessage).to receive(:search) { [message_1, message_2] }
+        get :index
+        expect(assigns(:messages)).to eq([message_1, message_2])
+      end
+    end
+
+    context 'GET :show' do
+      it 'retrieves the DatabaseChannelMessage' do
+        message = double
+        allow(DatabaseChannelMessage).to receive(:find).with('1') { message }
+        get :show, id: '1'
+        expect(assigns(:message)).to eq(message)
+      end
+    end
+  end
+end

data/spec/features/end_to_end_exception_handling_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_slow_helper'
+require 'harbinger'
+
+module Harbinger
+  describe 'handling a message', type: :feature do
+    let(:message) do
+      begin
+        {}.fetch(:missing_key)
+      rescue KeyError => exception
+        Harbinger.build_message(contexts: [exception])
+      end
+    end
+
+    it 'sends the exception message to the database channel' do
+      expect(Harbinger.logger).to receive(:add).at_least(:once).and_call_original
+
+      expect { Harbinger.deliver_message(message, channels: [:database, :logger]) }.
+        to change { DatabaseChannelMessage.count }.
+        by(1)
+
+      message = DatabaseChannelMessage.last
+
+      visit 'harbinger/messages'
+
+      # Search page
+      page.within('.search-form') do
+        page.fill_in('Search Text', with: 'KeyError')
+        page.click_button('Search')
+      end
+
+      page.find(:xpath, "//a[@href='#{harbinger.message_path(message.to_param)}']").click
+
+      expect(page.html).to have_tag('.message') do
+        with_tag('.message-contexts-detail', text: 'exception')
+        with_tag('.message-state-detail', text: 'new')
+      end
+    end
+  end
+end

data/spec/lib/harbinger/channels/database_channel_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_fast_helper'
+require 'harbinger/channels/database_channel'
+
+module Harbinger::Channels
+  describe DatabaseChannel do
+
+    it_should_behave_like "a harbinger channel"
+
+    context '.deliver' do
+      Given(:database_channel) { described_class }
+      Given(:storage) { double('Database', store_message: true ) }
+      Given(:message) { double("Message") }
+      When { database_channel.deliver(message, storage: storage) }
+      Then { expect(storage).to have_received(:store_message).with(message) }
+    end
+
+  end
+end

data/spec/lib/harbinger/channels/logger_channel_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_fast_helper'
+require 'harbinger/channels/logger_channel'
+
+module Harbinger::Channels
+  describe LoggerChannel do
+
+    it_should_behave_like "a harbinger channel"
+
+    context '.deliver' do
+      Given(:logger_channel) { described_class }
+      Given(:logger) { double('Logger', add: true ) }
+      Given(:severity) { double('Severity') }
+      Given(:message) { double("Message", attributes: {to_s: 'Hello'}) }
+      When { logger_channel.deliver(message, logger: logger, severity: severity) }
+      Then { expect(logger).to have_received(:add).with(severity, %(BEGIN MESSAGE OBJECT ID=#{message.object_id})) }
+      And { expect(logger).to have_received(:add).with(severity, %(:to_s => \"Hello\")) }
+      And { expect(logger).to have_received(:add).with(severity, %(END MESSAGE OBJECT ID=#{message.object_id})) }
+    end
+
+  end
+end

data/spec/lib/harbinger/channels/null_channel_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_fast_helper'
+require 'harbinger/channels/null_channel'
+
+module Harbinger::Channels
+  describe NullChannel do
+    it_should_behave_like "a harbinger channel"
+  end
+end

data/spec/lib/harbinger/channels_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_fast_helper'
+require 'harbinger/channels'
+
+module Harbinger
+  module Channels
+    class TestChannel
+      def self.deliver(message, config = {})
+      end
+    end
+  end
+
+  describe Channels do
+    context '.find_for' do
+
+      context 'existing named channel' do
+        Given(:channel_name) { :test }
+        When(:result) { described_class.find_for(channel_name) }
+        Then { expect(result).to eq(Channels::TestChannel) }
+        And { expect(result).to respond_to(:deliver) }
+      end
+
+      context 'missing named channel' do
+        Given(:channel_name) { :four_oh_four }
+        When(:result) { described_class.find_for(channel_name) }
+        Then { expect(result).to eq(Channels::NullChannel) }
+        And { expect(result).to respond_to(:deliver) }
+      end
+
+      context 'an exception happened' do
+        Given(:channel_name) { :test }
+        When(:result) do
+          expect(described_class).to receive(:channel_name_for_instance).and_raise(RuntimeError)
+          described_class.find_for(channel_name)
+        end
+        Then { expect(result).to eql(Channels::NullChannel) }
+      end
+
+    end
+  end
+end

data/spec/lib/harbinger/configuration_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_fast_helper'
+require 'harbinger/configuration'
+require 'logger'
+
+module Harbinger
+  describe Configuration do
+    Given(:configuration) { described_class.new }
+
+    context '#default_channels' do
+      When { configuration.default_channels = [:logger, 'Database'] }
+      Then { expect(configuration.default_channels).to eq([:logger, :database]) }
+    end
+
+    context '#default_channels without assignment' do
+      When(:default_channels) { configuration.default_channels }
+      Then { expect(default_channels).to eq([:logger]) }
+    end
+
+    context '#logger' do
+      context 'interface' do
+        Then { expect(configuration.logger).to respond_to :add }
+      end
+
+      context 'override with valid logger' do
+        Given(:logger) { double('Logger', add: true) }
+        When { configuration.logger = logger }
+        Then { expect(configuration.logger).to eq(logger) }
+      end
+
+      context 'override without valid logger' do
+        Given(:logger) { double('Logger') }
+        Then { expect { configuration.logger = logger }.to raise_error(ConfigurationError) }
+      end
+    end
+
+    context '#database_storage' do
+      context 'interface' do
+        Then { expect(configuration.database_storage).to respond_to :store_message }
+      end
+
+      context 'override with valid database_storage' do
+        Given(:database_storage) { double('Database Storage', store_message: true) }
+        When { configuration.database_storage = database_storage }
+        Then { expect(configuration.database_storage).to eq(database_storage) }
+      end
+
+      context 'override without valid database_storage' do
+        Given(:database_storage) { double('Database Storage') }
+        Then { expect { configuration.database_storage = database_storage }.to raise_error(ConfigurationError) }
+      end
+    end
+  end
+end

data/spec/lib/harbinger/message_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_fast_helper'
+require 'harbinger/message'
+
+module Harbinger
+  describe Message do
+    Given(:message) { described_class.new }
+
+    When { message.append('container', 'key', 'value')}
+    When { message.append('other_container', 'other_key', 'other_value')}
+
+    Then { expect(message.attributes).to eq({ 'container.key' => ['value'], 'other_container.other_key' => ['other_value']}) }
+    And { expect(message.contexts).to eq(['container', 'other_container']) }
+
+  end
+end

data/spec/lib/harbinger/reporters/exception_reporter_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_fast_helper'
+require 'harbinger/reporters/exception_reporter'
+
+module Harbinger::Reporters
+  describe ExceptionReporter do
+
+    it_should_behave_like "a harbinger reporter"
+
+    context 'specific behavior' do
+
+      Given(:message) { double('Message', append: true) }
+      Given(:exception_message) { 'exception message' }
+      Given(:exception) { RuntimeError.new(exception_message) }
+      Given(:reporter) { described_class.new(exception) }
+
+      When { reporter.accept(message) }
+
+      Then { expect(message).to have_received(:append).with('exception', 'class_name', exception.class.to_s) }
+      And { expect(message).to have_received(:append).with('exception', 'backtrace', [].join("\n")) }
+      And { expect(message).to have_received(:append).with('exception', 'message', exception.message) }
+
+    end
+  end
+end

data/spec/lib/harbinger/reporters/null_reporter_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_fast_helper'
+require 'harbinger/reporters/null_reporter'
+
+module Harbinger::Reporters
+  describe NullReporter do
+
+    it_should_behave_like "a harbinger reporter"
+
+    context 'specific behavior' do
+
+      Given(:message) { double('Message', append: true) }
+      Given(:context) { double('Request') }
+      Given(:reporter) { described_class.new(context) }
+
+      When { reporter.accept(message) }
+
+      Then { expect(message).to have_received(:append).with('nil', context.class.to_s, context.inspect) }
+
+    end
+  end
+end

data/spec/lib/harbinger/reporters/request_reporter_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_fast_helper'
+require 'harbinger/reporters/request_reporter'
+
+module Harbinger::Reporters
+  describe RequestReporter do
+
+    it_should_behave_like "a harbinger reporter"
+
+    context 'specific behavior' do
+
+      Given(:request) { double('Request', path: '/path/to/url', params: { id: 'id', contorller: 'controller'}, user_agent: 'user_agent' ) }
+      Given(:reporter) { described_class.new(request) }
+      Given(:message) { double('Message', append: true) }
+
+
+      When { reporter.accept(message) }
+      Then { expect(message).to have_received(:append).with('request', 'path', request.path) }
+      And { expect(message).to have_received(:append).with('request', 'params', request.params) }
+      And { expect(message).to have_received(:append).with('request', 'user_agent', request.user_agent) }
+
+    end
+  end
+end

data/spec/lib/harbinger/reporters/user_reporter_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_fast_helper'
+require 'harbinger/reporters/user_reporter'
+
+module Harbinger::Reporters
+  describe UserReporter do
+
+    it_should_behave_like "a harbinger reporter"
+
+    context 'specific behavior' do
+      Given(:user) { double('User', username: 'a username' ) }
+      Given(:message) { double('Message', append: true) }
+      Given(:reporter) { described_class.new(user) }
+      When { reporter.accept(message) }
+      Then { expect(message).to have_received(:append).with('user', 'username', user.username) }
+    end
+  end
+end

data/spec/lib/harbinger/reporters_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_fast_helper'
+require 'harbinger/reporters'
+
+module Harbinger
+  describe Reporters do
+    context '.find_for' do
+      Given(:reporter) { double('Reporter') }
+
+      context 'explicit conversion' do
+        Given(:context) { double('User', to_harbinger_reporter: reporter) }
+        When(:result) { described_class.find_for(context) }
+        Then { expect(result).to eq(reporter) }
+      end
+
+      context 'implicit conversion' do
+        Given(:context) { User.new }
+        When(:result) { described_class.find_for(context) }
+        Then { expect(result).to be_an_instance_of(Reporters::UserReporter) }
+      end
+
+      context 'implicit conversion of an exception' do
+        Given(:context) do
+          begin
+            {}.fetch(:missing_key)
+          rescue KeyError => exception
+            exception
+          end
+        end
+        When(:result) { described_class.find_for(context) }
+        Then { expect(result).to be_an_instance_of(Reporters::ExceptionReporter) }
+      end
+
+      context 'constant that raises a name error' do
+        Given(:context) { Class.new.new }
+        When(:result) { described_class.find_for(context) }
+        Then { expect(result).to be_an_instance_of(Reporters::NullReporter) }
+      end
+
+      context 'implicit conversion' do
+        Given(:context) { Object.new }
+        When(:result) { described_class.find_for(context) }
+        Then { expect(result).to be_an_instance_of(Reporters::NullReporter) }
+      end
+    end
+  end
+end

data/spec/lib/harbinger_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_fast_helper'
+require 'harbinger'
+require 'harbinger/message'
+
+describe Harbinger do
+  Given(:user) { User.new(username: 'a username') }
+  Given(:request) { Request.new(path: '/path/to/awesome', params: { hello: :world }, user_agent: "Ruby") }
+
+  context '.call' do
+    before(:each) do
+      expect(Harbinger::Channels).to receive(:find_for).with(channel_name).and_return(channel)
+    end
+    Given(:channel_name) { 'channel_double' }
+    Given(:channel_name) { 'channel_double' }
+    Given(:channel) { double('Channel', deliver: true) }
+    Given(:message) { Harbinger::Message.new }
+    When { Harbinger.call(contexts: [user, request], message: message, channels: channel_name) }
+    Then do expect(message.attributes).to eq(
+        'user.username' => [user.username],
+        'request.path' => [request.path],
+        'request.params' => [request.params],
+        'request.user_agent' => [request.user_agent]
+      )
+    end
+    And { expect(channel).to have_received(:deliver).with(message) }
+  end
+
+  context '.build_message' do
+    Given(:message) { Harbinger::Message.new }
+    When { Harbinger.build_message(contexts: [user, request], message: message) }
+    Then do expect(message.attributes).to eq(
+        'user.username' => [user.username],
+        'request.path' => [request.path],
+        'request.params' => [request.params],
+        'request.user_agent' => [request.user_agent]
+      )
+    end
+  end
+
+  context '.deliver_message' do
+    before(:each) do
+      expect(Harbinger::Channels).to receive(:find_for).with(channel_name).and_return(channel)
+    end
+    Given(:message) { Harbinger::Message.new }
+    Given(:channel_name) { 'channel_double' }
+    Given(:channel) { double('Channel', deliver: true) }
+    When { Harbinger.deliver_message(message, channels: channel_name) }
+    Then { expect(channel).to have_received(:deliver).with(message) }
+  end
+
+  context '.logger' do
+    Given(:logger) { Harbinger.logger }
+    Then { expect(logger).to respond_to :add }
+  end
+
+  context '.database_storage' do
+    Given(:database_storage) { Harbinger.database_storage }
+    Then { expect(database_storage).to respond_to :store_message }
+  end
+end

data/spec/models/harbinger/database_channel_message_element_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_active_record_helper'
+require 'harbinger/database_channel_message_element'
+
+module Harbinger
+  describe DatabaseChannelMessageElement do
+    context '.search_text' do
+      it 'handles a query parameter' do
+        expect(described_class.search_text('Hello').to_sql).to be_a(String)
+      end
+
+      it 'wild card searches the value' do
+        expect(described_class.search_text('Hello').to_sql).to match(/%Hello%/)
+      end
+    end
+  end
+end