rabbitmq_client 0.0.0.pre → 0.0.1

data/spec/lifecycle_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative 'support/dummy_rabbitmq_client_plugin'
+
+describe RabbitmqClient::Lifecycle do
+  subject { described_class.new }
+
+  let(:callback) { ->(*_args) {} }
+  let(:arguments) { [1, 2] }
+  let(:behavior) { double(Object, before!: nil, after!: nil, inside!: nil) }
+  let(:wrapped_block) { proc { behavior.inside! } }
+
+  describe 'before callbacks' do
+    before do
+      subject.before(:publish, &callback)
+    end
+
+    it 'executes before wrapped block' do
+      expect(callback).to receive(:call).with(*arguments).ordered
+      expect(behavior).to receive(:inside!).ordered
+      subject.run_callbacks :publish, *arguments, &wrapped_block
+    end
+  end
+
+  describe 'after callbacks' do
+    before do
+      subject.after(:publish, &callback)
+    end
+
+    it 'executes after wrapped block' do
+      expect(behavior).to receive(:inside!).ordered
+      expect(callback).to receive(:call).with(*arguments).ordered
+      subject.run_callbacks :publish, *arguments, &wrapped_block
+    end
+  end
+
+  it 'raises if callback is executed with wrong number of parameters' do
+    subject.before(:publish, &callback)
+    expect do
+      subject.run_callbacks(:publish, 1, 2, 3)
+    end.to raise_error(ArgumentError, /2 parameter/)
+  end
+
+  it 'raises for unsupported events' do
+    expect do
+      subject.before(:execute, &callback)
+    end.to raise_error(
+      RabbitmqClient::InvalidCallback,
+      /Unknown callback/
+    )
+  end
+
+  describe '#callbacks' do
+    before do
+      RabbitmqClient.instance_variable_set(:@lifecycle, nil)
+      RabbitmqClient.configure { |x| x[:plugins] << DummyRabbitmqClientPlugin }
+    end
+
+    after do
+      RabbitmqClient.configure { |x| x[:plugins] = [] }
+      RabbitmqClient.instance_variable_set(:@lifecycle, nil)
+    end
+
+    it 'load plugin callbacks' do
+      callbacks = RabbitmqClient.lifecycle.callbacks
+      first_callback = callbacks.values.first
+      last_callback = callbacks.values.last
+
+      expect(callbacks.keys).to eq [:publish]
+      expect(first_callback).to be_kind_of(RabbitmqClient::Callback)
+      expect(first_callback.instance_variable_get(:@before).count).to eq 1
+      expect(first_callback.instance_variable_get(:@after).count).to eq 1
+      expect(last_callback.instance_variable_get(:@before).count).to eq 1
+      expect(last_callback.instance_variable_get(:@after).count).to eq 1
+    end
+  end
+end

data/spec/plain_log_subscriber_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RabbitmqClient::PlainLogSubscriber do
+  class DummyEvent < ActiveSupport::Notifications::Event
+    def initialize(event_type, payload = {})
+      super(event_type, Time.now, Time.now, 1, payload)
+    end
+  end
+
+  let(:error) { double('error') }
+
+  before do
+    allow(error).to receive(:message).and_return('error')
+  end
+
+  describe '#publisher_created' do
+    it 'send logger a debug message' do
+      msg = 'The RabbitmqClient publisher is '\
+      'created with the follwong configs {}'
+      expect(subject.logger).to receive(:debug).with(msg)
+      subject.publisher_created(DummyEvent.new(
+                                  'publisher_created.rabbitmq_client',
+                                  {}
+                                ))
+    end
+  end
+
+  describe '#network_error' do
+    let(:payload) { { error: error, options: { exchange_name: 'exchange' } } }
+    it 'send logger a error message' do
+      expect(subject.logger).to receive(:error)
+        .with('Failed to publish a message (error) to exchange (exchange)')
+      subject.network_error(DummyEvent.new(
+                              'network_error.rabbitmq_client',
+                              payload
+                            ))
+    end
+  end
+  describe '#overriding_configs' do
+    it 'send logger a debug message' do
+      expect(subject.logger).to receive(:debug)
+        .with('Overriding the follwing configs for the created publisher {}')
+      subject.overriding_configs(DummyEvent.new(
+                                   'overriding_configs.rabbitmq_client',
+                                   {}
+                                 ))
+    end
+  end
+  describe '#publishing_message' do
+    it 'send logger a debug message' do
+      msg = 'Start>> Publishing a new message '\
+      '(message_id: undefined ) to the exchange (undefined)'
+      expect(subject.logger).to receive(:debug).with(msg)
+      subject.publishing_message(DummyEvent.new(
+                                   'publishing_message.rabbitmq_client',
+                                   {}
+                                 ))
+    end
+  end
+  describe '#published_message' do
+    it 'send logger a debug message' do
+      msg = '<<DONE Published a message to the '\
+            'exchange (undefined) with message_id: undefined'
+      expect(subject.logger).to receive(:info).with(msg)
+      subject.published_message(DummyEvent.new(
+                                  'published_message.rabbitmq_client',
+                                  {}
+                                ))
+    end
+  end
+  describe '#confirming_message' do
+    it 'send logger a debug message' do
+      expect(subject.logger).to receive(:debug)
+        .with('Start>> confirming a message (message_id: undefined)')
+      subject.confirming_message(DummyEvent.new(
+                                   'confirming_message.rabbitmq_client',
+                                   {}
+                                 ))
+    end
+  end
+  describe '#message_confirmed' do
+    it 'send logger a debug message' do
+      expect(subject.logger).to receive(:debug)
+        .with('<<DONE confirmed a message (message_id: undefined) Successfuly')
+      subject.message_confirmed(DummyEvent.new(
+                                  'message_confirmed.rabbitmq_client',
+                                  {}
+                                ))
+    end
+  end
+  describe '#exhange_not_found' do
+    let(:payload) { { name: 'exchange' } }
+    it 'send logger a error message' do
+      expect(subject.logger).to receive(:error)
+        .with('The Exchange \'exchange\' cannot be found')
+      subject.exhange_not_found(DummyEvent.new(
+                                  'exhange_not_found.rabbitmq_client',
+                                  payload
+                                ))
+    end
+  end
+  describe '#created_exhange' do
+    let(:payload) { { name: 'exchange' } }
+    it 'send logger a debug message' do
+      expect(subject.logger).to receive(:debug)
+        .with('The exchange exchange is created successfuly')
+      subject.created_exhange(DummyEvent.new(
+                                'created_exhange.rabbitmq_client',
+                                payload
+                              ))
+    end
+  end
+end

data/spec/plugin_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class EmptyRabbitmqClientPlugin < RabbitmqClient::Plugin
+end
+
+describe EmptyRabbitmqClientPlugin do
+  it 'raise an EmptyPlugin error' do
+    expect { described_class.new }.to raise_error(RabbitmqClient::EmptyPlugin)
+  end
+end

data/spec/publisher_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RabbitmqClient::Publisher do
+  describe '#initialize' do
+    context 'no configs is passed' do
+      let(:publisher) { described_class.new }
+      let(:default_session_params) do
+        { threaded: false, automatically_recover: false, heartbeat: 0 }
+      end
+
+      it 'create publisher with default values' do
+        expect(
+          publisher.instance_variable_get(:@session_params)
+        ).to eq default_session_params
+      end
+    end
+
+    context 'configs is passed' do
+      let(:session_params) do
+        { session_params: {
+          threaded: true,
+          automatically_recover: true,
+          heartbeat_publisher: 10
+        } }
+      end
+
+      let(:publisher) { described_class.new(session_params) }
+      let(:expected) do
+        { automatically_recover: false, heartbeat: 10,
+          heartbeat_publisher: 10, threaded: false }
+      end
+
+      it 'always overwrites automatically_recover and threaded' do
+        expect(publisher.instance_variable_get(:@session_params)).to eq expected
+      end
+
+      it 'use :heartbeat_publisher value for :heartbeat' do
+        expect(
+          publisher
+            .instance_variable_get(:@session_params)[:heartbeat]
+        ).to eq expected[:heartbeat_publisher]
+        expect(
+          publisher
+            .instance_variable_get(:@session_params)[:heartbeat_publisher]
+        ).to eq expected[:heartbeat_publisher]
+      end
+    end
+  end
+
+  describe '#publish' do
+    let(:bunny_session) { double('bunny_session') }
+    let(:bunny_channel) { double('bunny_channel') }
+    let(:exchange_name) { 'exchange' }
+    let(:exchange) { double('exchange') }
+    let(:confirmed) { true }
+
+    before do
+      allow(Bunny).to receive(:new).and_return(bunny_session)
+      allow(bunny_session).to receive(:start)
+      allow(bunny_session).to receive(:create_channel)
+        .and_return(bunny_channel)
+      allow(bunny_channel).to receive(:confirm_select)
+      allow(exchange).to receive(:create).and_return(exchange)
+      allow(exchange).to receive(:publish)
+      allow(exchange).to receive(:name).and_return('exchange')
+      allow(bunny_channel).to receive(:wait_for_confirms)
+        .and_return(confirmed)
+      allow(bunny_channel).to receive(:close)
+    end
+
+    context 'with minimum config' do
+      let(:publisher) { described_class.new }
+      it {
+        expect(publisher.publish({},
+                                 exchange_name: exchange_name)).to be_nil
+      }
+    end
+
+    context 'when confirmation fail' do
+      let(:exchange_registry) { double('exchange_registry') }
+      let(:publisher) do
+        described_class.new(exchange_registry: exchange_registry)
+      end
+
+      before do
+        expect(bunny_channel).to receive(:wait_for_confirms).and_return(false)
+        allow(bunny_channel).to receive(:nacked_set).and_return(1)
+        allow(bunny_channel).to receive(:unconfirmed_set).and_return(2)
+        allow(exchange_registry).to receive(:find).and_return(exchange)
+      end
+
+      it 'raises error' do
+        expect do
+          publisher.publish('message',
+                            message_id: 'abc',
+                            exchange_name: exchange_name)
+        end.to raise_error(
+          RabbitmqClient::MessagePublisher::ConfirmationFailed
+        )
+      end
+    end
+
+    context 'when exchange is not defined' do
+      let(:exchange_registry) { RabbitmqClient::ExchangeRegistry.new }
+      let(:publisher) do
+        described_class.new(exchange_registry: exchange_registry)
+      end
+      let(:type) { 'test' }
+      let(:options) { {} }
+
+      before do
+        exchange_registry.add(exchange_name, type, options)
+        allow(Bunny::Exchange).to receive(:new).and_return(exchange)
+      end
+
+      it 'defines exchange' do
+        publisher.publish('message',
+                          message_id: 'abc',
+                          exchange_name: exchange_name)
+        expect(
+          Bunny::Exchange
+        ).to have_received(:new)
+          .with(bunny_channel, type, exchange_name, options)
+      end
+    end
+
+    context 'when error raised' do
+      let(:error) { StandardError.new('network_error') }
+      let(:exchange_registry) { double('exchange_registry') }
+      let(:publisher) do
+        described_class.new(exchange_registry: exchange_registry)
+      end
+
+      before do
+        allow(exchange_registry).to receive(:find).and_return(exchange)
+        expect(bunny_channel).to receive(:wait_for_confirms).and_raise(error)
+      end
+
+      it 'raise an error' do
+        expect do
+          publisher.publish('message',
+                            message_id: 'abc',
+                            exchange_name: exchange_name)
+        end.to raise_error(error)
+      end
+    end
+  end
+end

data/spec/rabbitmq_client_spec.rb

@@ -4,4 +4,87 @@ RSpec.describe RabbitmqClient do
   it 'has a version number' do
     expect(RabbitmqClient::VERSION).not_to be nil
   end
+
+  describe '.add_exchange' do
+    let(:name) { 'exchange' }
+    let(:type) { 'test_exchange' }
+
+    it 'add exchange to the registry' do
+      registry = RabbitmqClient.instance_variable_get(:@exchange_registry)
+
+      expect do
+        registry.find(name)
+      end.to raise_error(
+        RabbitmqClient::ExchangeRegistry::ExchangeNotFound
+      )
+      RabbitmqClient.add_exchange(name, type {})
+      exchange = registry.find(name)
+
+      expect(exchange.name).to eq(name)
+      expect(exchange.type).to eq(type)
+      expect(exchange.options).to eq({})
+    end
+  end
+
+  describe '.publish' do
+    let(:publisher) { double('Publisher') }
+    let(:options) { { headers: { store: { uuid: '123456789' } } } }
+
+    before do
+      allow(RabbitmqClient::Publisher).to receive(:new).and_return(publisher)
+    end
+
+    it 'execute the publish callbacks with the mutated headers' do
+      expect(publisher).to receive(:publish).with('message', options)
+      RabbitmqClient.publish('message', options)
+    end
+  end
+
+  describe '.lifecycle' do
+    it 'return a RabbitmqClient::Lifecycle instance' do
+      expect(RabbitmqClient.lifecycle).to be_kind_of(RabbitmqClient::Lifecycle)
+    end
+  end
+
+  describe '.logger' do
+    context 'with default settings' do
+      before do
+        RabbitmqClient.instance_variable_set(:@logger, nil)
+      end
+      it 'return a STDOUT logger' do
+        logger = RabbitmqClient.logger
+        logdev = logger.instance_variable_get(:@logdev)
+        dev = logdev.instance_variable_get(:@dev)
+        expect(logger).to be_kind_of(Logger)
+        expect(logger.level).to eq(1)
+        expect(dev.inspect).to eq('#<IO:<STDOUT>>')
+      end
+    end
+    context 'with custome settings' do
+      let(:logger_configs) do
+        {
+          logs_format: 'plain',
+          logs_to_stdout: false,
+          logs_level: :debug,
+          logs_filename: 'testing.log'
+        }
+      end
+      before do
+        RabbitmqClient.instance_variable_set(:@logger, nil)
+        RabbitmqClient.configure do |config|
+          config.logger_configs = logger_configs
+        end
+      end
+
+      it 'create file logger' do
+        logger = RabbitmqClient.logger
+        logdev = logger.instance_variable_get(:@logdev)
+        dev = logdev.instance_variable_get(:@dev)
+        expect(RabbitmqClient.config.logger_configs).to eq(logger_configs)
+        expect(logger.level).to eq(0)
+        expect(logger).to be_kind_of(Logger)
+        expect(dev.inspect).to eq('#<File:testing.log>')
+      end
+    end
+  end
 end

data/spec/support/dummy_rabbitmq_client_plugin.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class DummyRabbitmqClientPlugin < RabbitmqClient::Plugin
+  callbacks do |lifecycle|
+    lifecycle.before(:publish) do |_message, options|
+      options[:user_id] = '10101010'
+      options[:user_name] = 'JohnDeo'
+    end
+    lifecycle.after(:publish) do |_delivery_info, _properties, _payload|
+      options[:user_id] = nil
+    end
+  end
+end

data/spec/tags_filter_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RabbitmqClient::TagsFilter do
+  describe '.tags' do
+    context 'using default values' do
+      it 'return nil as default' do
+        expect(RabbitmqClient::TagsFilter.tags).to eq(nil)
+      end
+    end
+
+    context 'using RequestStore as global store' do
+      let(:global_store) { double('Store') }
+      before do
+        RabbitmqClient.config.global_store = global_store
+      end
+
+      after do
+        RabbitmqClient.config.global_store = nil
+      end
+
+      it 'return empty hash as default' do
+        allow(global_store).to receive(:store).and_return({})
+        expect(RabbitmqClient::TagsFilter.tags).to eq({})
+      end
+
+      it 'fillter store keys and only return whitelisted keys' do
+        allow(global_store).to receive(:store).and_return(
+          not_allowed: 'test',
+          'x-request-id' => '1010'
+        )
+        expect(RabbitmqClient::TagsFilter.tags).to eq('x-request-id' => '1010')
+      end
+    end
+  end
+end

data/spec/text_formatter_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe RabbitmqClient::TextFormatter do
+  subject { described_class.new }
+  let(:message) { 'Test loG message' }
+  let(:global_store) { double('Store') }
+  let(:time) { Time.now }
+  let(:formated_time) { time.strftime('%Y-%m-%dT%H:%M:%S.%6N ') }
+
+  before do
+    RabbitmqClient.config.global_store = global_store
+  end
+
+  after do
+    RabbitmqClient.config.global_store = nil
+  end
+
+  describe '.call' do
+    it 'formatt the log message' do
+      allow(global_store).to receive(:store).and_return({})
+      log_line = subject.call('DEBUG', time, nil, message)
+      expect(log_line).to match(
+        /D, \[#{formated_time}#\d+\] DEBUG -- : #{message}/
+      )
+    end
+
+    it 'map int severity to string' do
+      allow(global_store).to receive(:store).and_return({})
+      log_line = subject.call(0, time, nil, message)
+      expect(log_line).to match(
+        /D, \[#{formated_time}#\d+\] DEBUG -- : #{message}/
+      )
+    end
+
+    it 'add tags to the log message' do
+      allow(global_store).to receive(:store).and_return('x-request-id': '10')
+      log_line = subject.call(1, time, nil, message)
+      expect(log_line).to match(
+        /I, \[#{formated_time}#\d+\]  INFO -- : \[x-request-id: 10\] #{message}/
+      )
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rabbitmq_client
 version: !ruby/object:Gem::Version
-  version: 0.0.0.pre
+  version: 0.0.1
 platform: ruby
 authors:
 - Al-waleed shihadeh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-22 00:00:00.000000000 Z
+date: 2019-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -192,6 +192,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.2.4
+- !ruby/object:Gem::Dependency
+  name: solargraph
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.37.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.37.2
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
@@ -212,28 +226,55 @@ email:
 - 'wshihadeh dot dev at gmail dot com '
 executables:
 - console
+- setup
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".overcommit.yml"
+- ".reek.yml"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
+- bin/setup
 - lib/rabbitmq_client.rb
+- lib/rabbitmq_client/callback.rb
+- lib/rabbitmq_client/exchange.rb
+- lib/rabbitmq_client/exchange_registry.rb
+- lib/rabbitmq_client/json_formatter.rb
+- lib/rabbitmq_client/json_log_subscriber.rb
+- lib/rabbitmq_client/lifecycle.rb
+- lib/rabbitmq_client/log_subscriber_base.rb
+- lib/rabbitmq_client/logger_builder.rb
+- lib/rabbitmq_client/message_publisher.rb
+- lib/rabbitmq_client/plain_log_subscriber.rb
+- lib/rabbitmq_client/plugin.rb
+- lib/rabbitmq_client/publisher.rb
+- lib/rabbitmq_client/tags_filter.rb
+- lib/rabbitmq_client/text_formatter.rb
 - lib/rabbitmq_client/version.rb
 - rabbitmq_client.gemspec
 - script/travis.sh
+- spec/callback_spec.rb
+- spec/exchange_registry_spec.rb
+- spec/json_formatter_spec.rb
+- spec/json_log_subscriber_spec.rb
+- spec/lifecycle_spec.rb
+- spec/plain_log_subscriber_spec.rb
+- spec/plugin_spec.rb
+- spec/publisher_spec.rb
 - spec/rabbitmq_client_spec.rb
 - spec/spec_helper.rb
+- spec/support/dummy_rabbitmq_client_plugin.rb
+- spec/tags_filter_spec.rb
+- spec/text_formatter_spec.rb
 homepage: https://github.com/wshihadeh/rabbitmq_client
 licenses:
 - MIT
@@ -251,14 +292,25 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: RabbitMq client library
 test_files:
+- spec/callback_spec.rb
+- spec/exchange_registry_spec.rb
+- spec/json_formatter_spec.rb
+- spec/json_log_subscriber_spec.rb
+- spec/lifecycle_spec.rb
+- spec/plain_log_subscriber_spec.rb
+- spec/plugin_spec.rb
+- spec/publisher_spec.rb
 - spec/rabbitmq_client_spec.rb
 - spec/spec_helper.rb
+- spec/support/dummy_rabbitmq_client_plugin.rb
+- spec/tags_filter_spec.rb
+- spec/text_formatter_spec.rb