liebre 0.1.21 → 0.2.1

data/spec/integration/rpc_communication_spec.rb

@@ -0,0 +1,81 @@
+RSpec.describe "RPC client-server communication" do
+
+  let(:connections) { {"test_conn" => {}} }
+
+  let :exchange do
+    {:name => "__test__.liebre.rpc_communication_exchange",
+     :type => "fanout",
+     :opts => {:auto_delete => true, :durable => false}}
+  end
+
+  let :client_queue do
+    {:prefix => "__test__.liebre.client_rpc_communication_queue"}
+  end
+
+  let :server_queue do
+    {:name => "__test__.liebre.server_rpc_communication_queue",
+     :opts => {:auto_delete => true, :durable => false}}
+  end
+
+  let(:handler_class) { double 'handler_class' }
+  let(:handler)       { double 'handler' }
+
+  let :actors do
+    {
+      :rpc_clients => {
+        :my_client => {
+          :connection => "test_conn",
+          :resources  => {:exchange => exchange, :queue => client_queue}
+        }
+      },
+      :rpc_servers => {
+        :my_server => {
+          :connection     => "test_conn",
+          :prefetch_count => 5,
+          :pool_size      => 1,
+          :handler        => handler_class,
+          :resources      => {:exchange => exchange, :queue => server_queue}
+        }
+      }
+    }
+  end
+
+  let :config do
+    Liebre::Config.new.tap do |config|
+      config.adapter     = Liebre::Adapter::Bunny
+      config.connections = connections
+      config.actors      = actors
+    end
+  end
+
+  let(:payload) { "some_data" }
+  let(:headers) { {"foo" => "bar"} }
+
+  let(:response) { "some_response" }
+
+  it "sends and receives data" do
+    engine = Liebre::Engine.new(config)
+    engine.start
+
+    repo       = engine.repo
+    rpc_client = repo.rpc_client(:my_client)
+
+    callback = nil
+    expect(handler_class).to receive :new do |payload, meta, given_callback|
+      expect(payload     ).to eq payload
+      expect(meta.headers).to eq headers
+      callback = given_callback
+
+      handler
+    end
+    expect(handler).to receive :call do
+      callback.reply(response)
+    end
+
+    sleep(0.1) # wait for all declarations and bindings to take place
+
+    opts = {:headers => headers}
+    expect(rpc_client.request(payload, opts, 0.2)).to eq response
+  end
+
+end

data/spec/integration/start_twice_spec.rb

@@ -0,0 +1,63 @@
+RSpec.describe "Start actors twice" do
+
+  let(:connections) { {"test_conn" => {}} }
+
+  let :exchange do
+    {:name => "__test__.liebre.publish_and_consume_exchange",
+     :type => "fanout",
+     :opts => {:auto_delete => true, :durable => false}}
+  end
+
+  let :queue do
+    {:name => "__test__.liebre.publish_and_consume_queue",
+     :opts => {:auto_delete => true, :durable => false}}
+  end
+
+  let(:handler_class) { double 'handler_class' }
+  let(:handler)       { double 'handler' }
+
+  let :actors do
+    {
+      :publishers => {
+        :my_publisher => {
+          :connection => "test_conn",
+          :resources  => {:exchange => exchange}
+        }
+      },
+      :consumers => {
+        :my_consumer => {
+          :connection     => "test_conn",
+          :prefetch_count => 5,
+          :pool_size      => 1,
+          :handler        => handler_class,
+          :resources      => {:exchange => exchange, :queue => queue}
+        }
+      }
+    }
+  end
+
+  let :config do
+    Liebre::Config.new.tap do |config|
+      config.adapter     = Liebre::Adapter::Bunny
+      config.connections = connections
+      config.actors      = actors
+    end
+  end
+
+  let(:payload) { "some_data" }
+  let(:headers) { {"foo" => "bar"} }
+
+  it "sends and receives data" do
+    engine = Liebre::Engine.new(config)
+    repo = engine.repo
+
+    engine.start(only: [:publishers, :rpc_servers])
+    expect(repo.publisher(:my_publisher)).not_to be nil
+    expect { repo.consumer(:my_consumer) }.to raise_error KeyError
+
+    engine.start()
+    expect(repo.publisher(:my_publisher)).not_to be nil
+    expect(repo.consumer(:my_consumer) ).not_to be nil
+  end
+
+end

data/spec/liebre/actor/consumer_spec.rb

@@ -0,0 +1,169 @@
+RSpec.describe Liebre::Actor::Consumer do
+
+  let(:chan)    { double 'chan' }
+  let(:declare) { double 'declare' }
+  let(:handler) { double 'handler' }
+
+  let :spec do
+    {:exchange => {:name => "foo"},
+     :queue    => {:name => "bar"},
+     :bind     => {:fake => "bind_config"}}
+  end
+
+  let(:logger) { double 'logger', :info => nil, :error => nil }
+
+  let :context do
+    double 'context', :chan    => chan,
+                      :declare => declare,
+                      :name    => "foo",
+                      :handler => handler,
+                      :spec    => spec,
+                      :logger  => logger
+  end
+
+  subject { described_class.new(context) }
+
+  let(:queue)    { double 'queue' }
+  let(:exchange) { double 'exchange' }
+
+  let(:dead_queue)    { double 'dead_queue' }
+  let(:dead_exchange) { double 'dead_exchange' }
+
+  let(:dead_letter_opts) do
+    {:arguments => {"x-dead-letter-exchange" => "bar-error"}}
+  end
+
+  before do
+    allow(subject).to receive(:async).and_return(subject)
+
+    allow(declare).to receive(:queue).
+      with(:name => "bar", :opts => dead_letter_opts).and_return(queue)
+
+    allow(declare).to receive(:exchange).
+      with(:name => "foo").and_return(exchange)
+
+    allow(declare).to receive(:queue).
+      with(:name => "bar-error", :opts => {}).and_return(dead_queue)
+
+    allow(declare).to receive(:exchange).
+      with(:name => "bar-error", :type => "fanout", :opts => {}).and_return(dead_exchange)
+
+    allow(declare).to receive(:bind).
+      with(queue, exchange, :fake => "bind_config")
+
+    allow(declare).to receive(:bind).
+      with(dead_queue, dead_exchange)
+  end
+
+  let(:info)    { double 'info' }
+  let(:meta)    { double 'meta' }
+  let(:payload) { "some_data" }
+
+  describe '#start' do
+    it 'declares and binds queue and exchange, and subscribes to the queue' do
+      expect(declare).to receive(:queue).
+        with(:name => "bar", :opts => dead_letter_opts).and_return(queue)
+
+      expect(declare).to receive(:exchange).
+        with(:name => "foo").and_return(exchange)
+
+      expect(declare).to receive(:bind).
+        with(queue, exchange, :fake => "bind_config")
+
+      expect(declare).to receive(:queue).
+        with(:name => "bar-error", :opts => {}).and_return(dead_queue)
+
+      expect(declare).to receive(:exchange).
+        with(:name => "bar-error", :type => "fanout", :opts => {}).and_return(dead_exchange)
+
+      expect(declare).to receive(:bind).
+        with(dead_queue, dead_exchange)
+
+      subscription_block = nil
+      expect(queue).to receive(:subscribe) do |opts, &block|
+        expect(opts).to eq :block => false, :manual_ack => true
+        subscription_block = block
+      end
+
+      subject.start
+
+      expect(subject).to receive(:consume).
+        with(info, meta, payload)
+
+      subscription_block.(info, meta, payload)
+    end
+  end
+
+  describe '#clean' do
+    it 'deletes all queues and exchanges' do
+      expect(queue        ).to receive(:delete)
+      expect(exchange     ).to receive(:delete)
+      expect(dead_queue   ).to receive(:delete)
+      expect(dead_exchange).to receive(:delete)
+
+      subject.clean
+    end
+  end
+
+  describe '#consume' do
+    context 'on success' do
+      it 'runs the handler with a callbacks object' do
+        callback = nil
+        expect(handler).to receive :call do |given_payload, given_meta, given_callback|
+          expect(given_payload).to eq payload
+          expect(given_meta   ).to eq meta
+
+          callback = given_callback
+        end
+
+        subject.consume(info, meta, payload)
+
+        expect(subject).to receive(:ack).with(info, {})
+        callback.ack()
+
+        expect(subject).to receive(:nack).with(info, {})
+        callback.nack()
+
+        expect(subject).to receive(:reject).with(info, :requeue => true)
+        callback.reject(:requeue => true)
+      end
+    end
+
+    context 'on handler failure' do
+      let(:error) { double 'error' }
+
+      it 'calls failed on the consumer' do
+        error_block = nil
+        expect(handler).to receive :call do |payload, meta, callback, &block|
+          error_block = block
+        end
+
+        subject.consume(info, meta, payload)
+
+        expect(subject).to receive(:failed).
+          with(info, error)
+
+        error_block.(error)
+      end
+    end
+  end
+
+  describe '#ack, #nack, #reject and #failed' do
+    let(:error) { double 'error', :message => "foo", :backtrace => [] }
+
+    it 'delegates to the queue' do
+      expect(queue).to receive(:ack).with(info, {})
+      subject.ack(info)
+
+      expect(queue).to receive(:nack).with(info, {})
+      subject.nack(info)
+
+      expect(queue).to receive(:reject).with(info, :requeue => true)
+      subject.reject(info, :requeue => true)
+
+      expect(queue).to receive(:reject).with(info, {})
+      subject.failed(info, error)
+    end
+  end
+
+end

data/spec/liebre/actor/context/declare_spec.rb

@@ -0,0 +1,69 @@
+RSpec.describe Liebre::Actor::Context::Declare do
+
+  let(:chan) { double 'chan' }
+
+  subject { described_class.new(chan) }
+
+  describe '#default_exchange' do
+    let(:default_exchange) { double 'default_exchange' }
+
+    it 'builds the default exchange' do
+      expect(chan).to receive(:default_exchange).
+        and_return(default_exchange)
+
+      expect(subject.default_exchange).to eq default_exchange
+    end
+  end
+
+  describe '#exchange' do
+    let(:exchange) { double 'exchange' }
+
+    let :opts do
+      {:name => "foo",
+       :type => "fanout",
+       :opts => {:durable => true}}
+    end
+
+    it 'builds an exchange with the given options' do
+      expect(chan).to receive(:exchange).
+        with("foo", "fanout", :durable => true).
+        and_return(exchange)
+
+      expect(subject.exchange(opts)).to eq exchange
+    end
+  end
+
+  describe '#queue' do
+    let(:queue) { double 'queue' }
+
+    let :opts do
+      {:name => "foo",
+       :opts => {:durable => true}}
+    end
+
+    it 'builds an queue with the given options' do
+      expect(chan).to receive(:queue).
+        with("foo", :durable => true).
+        and_return(queue)
+
+      expect(subject.queue(opts)).to eq queue
+    end
+  end
+
+  describe '#bind' do
+    let(:queue)    { double 'queue' }
+    let(:exchange) { double 'exchange' }
+    let(:opts)     { [{:routing_key => "foo"}, {:routing_key => "bar"}] }
+
+    it 'binds as many option sets as given' do
+      expect(queue).to receive(:bind).
+        with(exchange, :routing_key => "foo")
+
+      expect(queue).to receive(:bind).
+        with(exchange, :routing_key => "bar")
+
+      subject.bind(queue, exchange, opts)
+    end
+  end
+
+end

data/spec/liebre/actor/context/handler_spec.rb

@@ -0,0 +1,65 @@
+RSpec.describe Liebre::Actor::Context::Handler do
+
+  let(:pool_size)     { 3 }
+  let(:handler_class) { double 'handler_class' }
+
+  let :opts do
+    {:pool_size => pool_size,
+     :handler   => handler_class}
+  end
+
+  subject { described_class.new(opts) }
+
+  let(:pool) { double 'pool' }
+
+  before do
+    allow(Concurrent::FixedThreadPool).to receive(:new).
+      with(pool_size).and_return(pool)
+  end
+
+  describe '#call' do
+    def pool_block *args, &block
+      pool_block = nil
+      expect(pool).to receive :post do |&given_block|
+        pool_block = given_block
+      end
+
+      subject.call(*args, &block)
+      pool_block
+    end
+
+    let(:handler) { double 'handler' }
+
+    context 'on success' do
+      it 'runs the handler on the pool' do
+        block = pool_block("foo", "bar") {}
+
+        expect(handler_class).to receive(:new).
+          with("foo", "bar").and_return(handler)
+
+        expect(handler).to receive(:call)
+
+        block.()
+      end
+    end
+
+    context 'on handler error' do
+      let(:target) { double 'target' }
+
+      it 'runs the given block with the error as argument' do
+        block = pool_block("foo") { target.boom! }
+
+        expect(target).to receive(:boom!)
+
+        expect(handler_class).to receive(:new).
+          with("foo").and_return(handler)
+
+        expect(handler).to receive(:call).
+          and_raise("boom")
+
+        block.()
+      end
+    end
+  end
+
+end