vx-common-amqp 0.2.6

data/lib/vx/common/amqp.rb

@@ -0,0 +1,68 @@
+require File.expand_path("../amqp/version", __FILE__)
+
+module Vx
+  module Common
+    module AMQP
+
+      autoload :Config,     File.expand_path("../amqp/config",    __FILE__)
+      autoload :Session,    File.expand_path("../amqp/session",   __FILE__)
+      autoload :Consumer,   File.expand_path("../amqp/consumer",  __FILE__)
+      autoload :CLI,        File.expand_path("../amqp/cli",       __FILE__)
+      autoload :Formatter,  File.expand_path("../amqp/formatter", __FILE__)
+
+      module Supervisor
+        autoload :Threaded, File.expand_path("../amqp/supervisor/threaded", __FILE__)
+      end
+
+      autoload :Logger,         File.expand_path("../amqp/mixins/logger",          __FILE__)
+      autoload :Callbacks,      File.expand_path("../amqp/mixins/callbacks",       __FILE__)
+
+      extend self
+
+      @@config  = Common::AMQP::Config.new
+      @@session = Common::AMQP::Session.new
+
+      def configure
+        yield config
+      end
+
+      def config
+        @@config
+      end
+
+      def session
+        @@session
+      end
+
+      def open
+        session.open
+      end
+
+      def open?
+        session.open?
+      end
+
+      def close
+        session.close
+      end
+
+      def logger
+        config.logger
+      end
+
+      def logger=(val)
+        config.logger = val
+      end
+
+      def shutdown
+        Common::AMQP::Session.shutdown
+        Vx::Common::AMQP::Supervisor::Threaded.shutdown
+      end
+
+      def shutdown?
+        Common::AMQP::Session.shutdown?
+      end
+
+    end
+  end
+end

data/spec/integration/multi_threaded_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'thread'
+require 'timeout'
+
+class Vx::BobThread
+  include Vx::Common::AMQP::Consumer
+
+  queue    exclusive: true, durable: false
+  exchange auto_delete: true, durable: false
+  ack      true
+
+  def perform(payload)
+    $mtest_mutex.synchronize do
+      $mtest_collected << payload
+      ack!
+      sleep 0.1
+    end
+  end
+end
+
+class Vx::AliceThread
+  include Vx::Common::AMQP::Consumer
+
+  queue    exclusive: true, durable: false
+  exchange auto_delete: true, durable: false
+  ack      true
+
+  def perform(payload)
+    Vx::BobThread.publish payload, content_type: properties[:content_type]
+    ack!
+    sleep 0.1
+  end
+end
+
+describe "Run in multithread environment", slow: true, jruby: true do
+  let(:num_messages) { 100 }
+  let(:alice)   { Vx::AliceThread }
+  let(:bob)     { Vx::BobThread }
+  let(:sess)    { Vx::Common::AMQP.open }
+  let(:ch)      { sess.conn.create_channel }
+
+  before do
+    $mtest_mutex = Mutex.new
+    $mtest_collected = []
+  end
+
+  after do
+    sess.close
+  end
+
+  it "should be successfuly" do
+    ths = (0..12).map do |i|
+      klass = (i % 2 == 0) ? alice : bob
+      Thread.new do
+        begin
+          klass.subscribe
+        rescue Exception => e
+          puts "ERROR: #{e.inspect}"
+          raise e
+        end
+      end.tap do |th|
+        th.abort_on_exception = true
+      end
+    end
+    sleep 0.5
+
+    num_messages.times do |n|
+      alice.publish "n#{n}", content_type: "text/plain"
+    end
+
+    Timeout.timeout(60) do
+      loop do
+        stop = false
+        $mtest_mutex.synchronize do
+          puts $mtest_collected.size
+          stop = true if $mtest_collected.size >= num_messages
+        end
+        break if stop
+        sleep 2
+      end
+    end
+
+    Vx::Common::AMQP.shutdown
+    Timeout.timeout(10) { ths.map{|i| i.join } }
+
+    expect($mtest_collected.sort).to eq (0...num_messages).map{|i| "n#{i}" }.sort
+  end
+
+end

data/spec/integration/threaded_supervisor_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'thread'
+require 'timeout'
+
+class Vx::BobThreadWithSupervisor
+  include Vx::Common::AMQP::Consumer
+
+  class ErrorSimulation < ::Exception ; end
+
+  queue    exclusive: true, durable: false
+  exchange auto_delete: true, durable: false
+  ack      true
+
+  def perform(payload)
+    $mtest_mutex.synchronize do
+      raise IgnoreMeError if Random.new(delivery_info.delivery_tag.to_i).rand < 0.2
+      $mtest_collected << payload
+      ack!
+      sleep 0.1
+    end
+  end
+end
+
+class Vx::AliceThreadWithSupervisor
+  include Vx::Common::AMQP::Consumer
+
+  queue    exclusive: true, durable: false
+  exchange auto_delete: true, durable: false
+  ack      true
+
+  def perform(payload)
+    Vx::BobThreadWithSupervisor.publish payload, content_type: properties[:content_type]
+    ack!
+    sleep 0.1
+  end
+end
+
+describe "Run in multithread environment", slow: true, jruby: true do
+  let(:num_messages) { 100 }
+  let(:alice)   { Vx::AliceThreadWithSupervisor }
+  let(:bob)     { Vx::BobThreadWithSupervisor }
+  let(:sess)    { Vx::Common::AMQP.open }
+  let(:ch)      { sess.conn.create_channel }
+
+  before do
+    $mtest_mutex = Mutex.new
+    $mtest_collected = []
+  end
+
+  after do
+    sess.close
+  end
+
+  it "should be successfuly" do
+
+    supervisor = Vx::Common::AMQP::Supervisor::Threaded.build alice => 6, bob => 6
+
+    supervisor_thread = supervisor.run_async
+
+    sleep 0.5
+
+    num_messages.times do |n|
+      alice.publish "n#{n}", content_type: "text/plain"
+    end
+
+    Timeout.timeout(60) do
+      loop do
+        stop = false
+        $mtest_mutex.synchronize do
+          puts $mtest_collected.size
+          stop = true if $mtest_collected.size >= num_messages
+        end
+        break if stop
+        sleep 2
+      end
+    end
+
+    Vx::Common::AMQP.shutdown
+    supervisor.shutdown
+    Timeout.timeout(10) { supervisor_thread.join }
+
+    expect($mtest_collected.sort).to eq (0...num_messages).map{|i| "n#{i}" }.sort
+  end
+
+end

data/spec/lib/amqp/config_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Vx::Common::AMQP::Config do
+  let(:config) { described_class.new }
+
+  context '(callbacks)' do
+    %w{ before after }.each do |p|
+      %w{ subscribe recieve publish }.each do |m|
+        name = "#{p}_#{m}"
+        it name do
+          config.public_send name do |value|
+            value
+          end
+
+          val = config.callbacks[name.to_sym].call("value")
+          expect(val).to eq 'value'
+        end
+      end
+    end
+
+    context "on_error" do
+      it "should be success" do
+        config.on_error do |e|
+          e
+        end
+        val = config.callbacks[:on_error].call "value"
+        expect(val).to eq 'value'
+      end
+    end
+  end
+
+end

data/spec/lib/amqp/consumer_spec.rb

@@ -0,0 +1,316 @@
+require 'spec_helper'
+require 'timeout'
+require 'json'
+
+class Vx::TestConsumer
+  include Vx::Common::AMQP::Consumer
+
+  ack true
+
+  def perform(payload)
+    Thread.current[:collected] ||= []
+    Thread.current[:collected] << payload
+    ack!
+
+    :shutdown if Thread.current[:collected].size == 3
+  end
+end
+
+describe Vx::Common::AMQP::Consumer do
+
+  let(:consumer) { Vx::TestConsumer.new }
+  let(:consumer_class) { consumer.class }
+
+  subject { consumer }
+
+  before { consumer_class.reset_consumer_configuration! }
+
+  context '(configuration)' do
+
+    subject { consumer_class }
+
+    its(:config)        { should be_an_instance_of(Vx::Common::AMQP::Config) }
+    its(:consumer_name) { should eq 'test_consumer' }
+
+    context "consumer_id" do
+
+      it "should be success" do
+        expect(consumer_class.consumer_id).to eq 'test_consumer'
+        th = Thread.new do
+          Thread.current[:vx_amqp_consumer_id] = '99'
+          consumer_class.consumer_id
+        end
+        expect(th.value).to eq 'test_consumer.99'
+      end
+    end
+
+
+    context "model" do
+      subject { consumer_class.model }
+
+      it "by default should be nil" do
+        expect(subject).to be_nil
+      end
+
+      it 'when set model should be' do
+        consumer_class.model Hash
+        expect(subject).to eq Hash
+      end
+    end
+
+    context "content_type" do
+
+      subject { consumer_class.content_type }
+
+      it "by default should be nil" do
+        expect(subject).to be_nil
+      end
+
+      it 'when set content type should be' do
+        consumer_class.content_type 'foo'
+        expect(subject).to eq 'foo'
+      end
+    end
+
+    context "bind_options" do
+      subject { consumer_class.bind_options }
+
+      context "by default should eq {}" do
+        it { should eq ({}) }
+      end
+
+      context "set routing_key" do
+        before { consumer_class.routing_key 'key' }
+        it { should eq(routing_key: 'key') }
+      end
+
+      context "set routing_key by block" do
+        before do
+          consumer_class.routing_key { 'key.block' }
+        end
+        it { should eq(routing_key: 'key.block') }
+      end
+
+      context "set headers" do
+        before { consumer_class.headers 'key' }
+        it { should eq({headers: 'key'}) }
+      end
+
+      context "set headers by block" do
+        before { consumer_class.headers { 'key.block' } }
+        it { should eq(headers: 'key.block') }
+      end
+    end
+
+    context "ack" do
+      subject { consumer_class.ack }
+
+      it "by default should be false" do
+        expect(subject).to be_false
+      end
+
+      it "when set to true should be true" do
+        consumer_class.ack true
+        expect(subject).to be_true
+      end
+    end
+
+    context "exchange_name" do
+      subject { consumer_class.exchange_name }
+
+      it 'by default should eq consumer_name' do
+        expect(subject).to eq consumer_class.consumer_name
+      end
+
+      it "when set name should be" do
+        consumer_class.exchange :foo
+        expect(subject).to eq :foo
+      end
+
+      it "when set by block should be" do
+        consumer_class.exchange { 'name.block' }
+        expect(subject).to eq 'name.block'
+      end
+    end
+
+    context "queue_name" do
+      subject{ consumer_class.queue_name }
+      it 'by default should eq consumer_name' do
+        expect(subject).to eq consumer_class.consumer_name
+      end
+
+      it "when set name should be" do
+        consumer_class.queue :bar
+        expect(subject).to eq :bar
+      end
+
+      it "when set by block should be" do
+        consumer_class.queue { 'name.block' }
+        expect(subject).to eq 'name.block'
+      end
+    end
+
+    %w{ queue exchange }.each do |m|
+      context "#{m}_options" do
+        subject { consumer_class.send "#{m}_options" }
+        it 'by default should eq {}' do
+          expect(subject).to eq({})
+        end
+
+        it "when set #{m} options should be" do
+          consumer_class.send(m, durable: true)
+          expect(subject).to eq(durable: true)
+        end
+      end
+    end
+
+    %w{ routing_key headers }.each do |m|
+      context m do
+        subject { consumer_class.send m }
+
+        it 'by default should be nil' do
+          expect(subject).to be_nil
+        end
+
+        it "when set #{m} should be" do
+          consumer_class.send(m, key: :value)
+          expect(subject).to eq(key: :value)
+        end
+      end
+    end
+  end
+
+  context "(publish)" do
+
+    context "options" do
+      let(:message)          { {"foo" => 1, "bar" => 2} }
+      let(:expected_options) { {} }
+      let(:options)          { {} }
+      let(:x)                { OpenStruct.new name: "name" }
+
+      subject{ consumer_class.publish message, options }
+
+      before do
+        mock(consumer_class).declare_exchange { x }
+        mock(x).publish(message.to_json, expected_options)
+      end
+
+      context "routing_key" do
+        context "by default" do
+          it { should be }
+        end
+
+        context "when exists in configuration" do
+          let(:expected_options) { { routing_key: 'routing.key' } }
+          before do
+            consumer_class.routing_key 'routing.key'
+          end
+          it { should be }
+        end
+
+        context "when exists in options" do
+          let(:expected_options) { { routing_key: 'routing.key' } }
+          let(:options)          { { routing_key: 'routing.key' } }
+          it { should be }
+        end
+
+        context "when exists in options and configuration" do
+          let(:expected_options) { { routing_key: 'options.key' } }
+          let(:options)          { { routing_key: 'options.key' } }
+          before do
+            consumer_class.routing_key 'configuration.key'
+          end
+          it { should be }
+        end
+      end
+
+      context "headers" do
+        context "by default" do
+          it { should be }
+        end
+
+        context "when exists in configuration" do
+          let(:expected_options) { { headers: 'key' } }
+          before do
+            consumer_class.headers 'key'
+          end
+          it { should be }
+        end
+
+        context "when exists in options" do
+          let(:expected_options) { { headers: 'key' } }
+          let(:options)          { { headers: 'key' } }
+          it { should be }
+        end
+
+        context "when exists in options and configuration" do
+          let(:expected_options) { { headers: 'options' } }
+          let(:options)          { { headers: 'options' } }
+          before do
+            consumer_class.headers 'configuration'
+          end
+          it { should be }
+        end
+      end
+    end
+
+    context "real run" do
+      let(:x_name)  { consumer_class.exchange_name      }
+      let(:q_name)  { consumer_class.queue_name         }
+      let(:sess)    { consumer_class.session.open       }
+      let(:ch)      { sess.conn.create_channel          }
+      let(:q)       { sess.declare_queue q_name, channel: ch    }
+      let(:x)       { sess.declare_exchange x_name, channel: ch }
+      let(:message) { { 'key' => 'value' } }
+
+      after do
+        delete_queue q
+        delete_exchange x
+        sess.close
+      end
+
+      before do
+        q.bind x
+      end
+
+      it "should publish message to exchange using settings from consumer" do
+        consumer_class.publish message
+        sleep 0.25
+        expect(q.message_count).to eq 1
+        _, _, expected = q.pop
+        expect(expected).to eq message.to_json
+      end
+    end
+  end
+
+  context '(subscribe)' do
+    let(:x_name)  { consumer_class.exchange_name      }
+    let(:q_name)  { consumer_class.queue_name         }
+    let(:sess)    { consumer_class.session.open       }
+    let(:ch)      { sess.conn.create_channel          }
+    let(:q)       { sess.declare_queue q_name, channel: ch    }
+    let(:x)       { sess.declare_exchange x_name, channel: ch }
+
+    after do
+      delete_queue q
+      delete_exchange x
+      sess.close
+    end
+
+    before do
+      consumer_class.ack true
+      q.bind(x)
+      3.times { |n| x.publish({"n" => n}.to_json, content_type: "application/json") }
+    end
+
+    subject { Thread.current[:collected] }
+
+    it "should receive messages" do
+      Timeout.timeout(3) do
+        consumer_class.subscribe
+      end
+      expect(subject).to have(3).items
+      expect(subject.map(&:values).flatten).to eq [0,1,2]
+    end
+  end
+end

data/spec/lib/amqp/formatter_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'json'
+
+class FormatterConsumerTest
+  include Vx::Common::AMQP::Consumer
+
+  model Hash
+end
+
+describe Vx::Common::AMQP::Formatter do
+  let(:consumer) { FormatterConsumerTest.new }
+  subject        { described_class           }
+
+  context "pack" do
+    let(:body) { { "a" => 1, "b" => 2 } }
+
+    it "should pack message" do
+      expect(subject.pack 'application/json', body).to eq body.to_json
+      expect(subject.pack :foo, body).to be_nil
+    end
+
+  end
+
+  context "unpack" do
+    let(:body) { { "a" => 1, "b" => 2 } }
+
+    before do
+      mock(Hash).from_json(body.to_json) { body }
+    end
+
+    it "should unpack message" do
+      expect(subject.unpack 'application/json', Hash, body.to_json).to eq body
+      expect(subject.unpack :foo, Hash, body.to_json).to be_nil
+    end
+
+  end
+
+  context "lookup" do
+
+    it "should find format by content type" do
+      expect(subject.lookup('application/json').content_type).to eq 'application/json'
+      expect(subject.lookup(:foo)).to be_nil
+    end
+
+  end
+
+end

data/spec/lib/amqp/mixins/callbacks_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Vx::Common::AMQP::Callbacks do
+  let(:output) { [] }
+  let(:object) { Object.new.extend described_class }
+
+  before do
+    Vx::Common::AMQP.config.reset!
+    Vx::Common::AMQP.configure do |c|
+      c.before_publish { |v| output << "before:#{v}" }
+      c.after_publish  { |v| output << "after:#{v}" }
+    end
+  end
+
+  after  { Vx::Common::AMQP.config.reset! }
+
+  context 'run_callbacks' do
+    it "should be success" do
+      object.run_callbacks :publish, "call" do
+        output << "call"
+      end
+      expect(output).to eq %w{ before:call call after:call }
+    end
+  end
+end
+