liebre 0.1.21 → 0.2.1

data/spec/liebre/actor/publisher_spec.rb

@@ -0,0 +1,58 @@
+RSpec.describe Liebre::Actor::Publisher do
+
+  let(:chan)    { double 'chan' }
+  let(:declare) { double 'declare' }
+  let(:spec)    { {:exchange => {:fake => "config"}} }
+  let(:logger)  { double 'logger', :info => nil, :error => nil }
+
+  let :context do
+    double 'context', :chan    => chan,
+                      :declare => declare,
+                      :name    => "foo",
+                      :spec    => spec,
+                      :logger  => logger
+  end
+
+  subject { described_class.new(context) }
+
+  before do
+    allow(subject).to receive(:async).and_return(subject)
+  end
+
+  let(:exchange) { double 'exchange' }
+
+  before do
+    allow(declare).to receive(:exchange).
+      with(:fake => "config").and_return(exchange)
+  end
+
+  describe '#start' do
+    it 'declares the exchange' do
+      expect(declare).to receive(:exchange).
+        with(:fake => "config").and_return(exchange)
+
+      subject.start
+    end
+  end
+
+  describe '#clean' do
+    it 'deletes the exchange' do
+      expect(exchange).to receive(:delete)
+
+      subject.clean
+    end
+  end
+
+  describe '#publish' do
+    it 'publishes through the exchange' do
+      allow(declare).to receive(:exchange).
+        with(:fake => "config").and_return(exchange)
+
+      expect(exchange).to receive(:publish).
+        with("some_data", :routing_key => "bar")
+
+      subject.publish("some_data", :routing_key => "bar")
+    end
+  end
+
+end

data/spec/liebre/actor/rpc/client_spec.rb

@@ -0,0 +1,126 @@
+require 'concurrent'
+
+RSpec.describe Liebre::Actor::RPC::Client do
+
+  let(:chan)    { double 'chan' }
+  let(:declare) { double 'declare' }
+
+  let :spec do
+    {:exchange => {:fake   => "exchange_config"},
+     :queue    => {:prefix => "client_test"},
+     :bind     => {:fake   => "bind_config"}}
+  end
+
+  let(:logger) { double 'logger', :info => nil, :error => nil }
+
+  let :context do
+    double 'context', :chan    => chan,
+                      :declare => declare,
+                      :name    => "foo",
+                      :spec    => spec,
+                      :logger  => logger
+  end
+
+  subject { described_class.new(context) }
+
+  let(:response_queue)   { double 'request_queue', :name => "queue_1234" }
+  let(:request_exchange) { double 'request_exchange' }
+  let(:task)             { double 'task', :execute => true, :shutdown => true }
+
+  before do
+    allow(subject).to receive(:async).and_return(subject)
+
+    allow(declare).to receive :queue do |config|
+      expect(config[:name]).to match /^client_test_.+$/
+      expect(config[:opts]).to eq :auto_delete => true, :exclusive => true, :durable => false
+
+      response_queue
+    end
+
+    allow(declare).to receive(:exchange).
+      with(:fake => "exchange_config").and_return(request_exchange)
+
+    allow(Concurrent::TimerTask).to receive(:new).
+      with(anything).and_return(task)
+  end
+
+  let(:info)     { double 'info' }
+  let(:meta)     { double 'meta' }
+  let(:payload)  { "some_payload" }
+  let(:response) { "some_response" }
+
+  describe '#start' do
+    it 'declares queue and exchange, and subscribes to the queue' do
+      expect(declare).to receive :queue do |config|
+        expect(config[:name]).to match /^client_test_.+$/
+        expect(config[:opts]).to eq :auto_delete => true, :exclusive => true, :durable => false
+
+        response_queue
+      end
+
+      expect(declare).to receive(:exchange).
+        with(:fake => "exchange_config").and_return(request_exchange)
+
+      subscription_block = nil
+      expect(response_queue).to receive(:subscribe) do |opts, &block|
+        expect(opts).to eq :block => false, :manual_ack => false
+        subscription_block = block
+      end
+
+      task_block = nil
+      expect(Concurrent::TimerTask).to receive(:new) do |opts, &block|
+        expect(opts[:execution_interval]).to be_a Numeric
+        task_block = block
+
+        task
+      end
+      expect(task).to receive(:execute)
+
+      subject.start
+
+      expect(subject).to receive(:reply).with(meta, response)
+      subscription_block.(info, meta, response)
+
+      expect(subject).to receive(:expire)
+      task_block.()
+    end
+  end
+
+  describe '#clean' do
+    it 'deletes queue and exchange' do
+      expect(response_queue  ).to receive(:delete)
+      expect(request_exchange).to receive(:delete)
+
+      subject.clean
+    end
+  end
+
+  describe '#request and #reply' do
+    it 'replies and releases the client only when a matching response is received' do
+      correlation_id = nil
+      expect(request_exchange).to receive :publish do |given_payload, opts|
+        expect(payload        ).to eq payload
+        expect(opts[:reply_to]).to eq "queue_1234"
+
+        correlation_id = opts[:correlation_id]
+      end
+
+      thread = Thread.new do
+        subject.request(payload)
+      end
+      sleep(0.1)
+      expect(thread.alive?).to eq true # waiting for response
+
+      no_matching_meta = double("not_matching_meta", :correlation_id => "not-matching")
+      subject.reply(no_matching_meta, response)
+      sleep(0.1)
+      expect(thread.alive?).to eq true # waiting for a matching response
+
+      matching_meta = double("matching_meta", :correlation_id => correlation_id)
+      subject.reply(matching_meta, response)
+      sleep(0.1)
+      expect(thread.value).to eq response
+    end
+  end
+
+end

data/spec/liebre/actor/rpc/server_spec.rb

@@ -0,0 +1,141 @@
+RSpec.describe Liebre::Actor::RPC::Server do
+
+  let(:chan)    { double 'chan' }
+  let(:declare) { double 'declare' }
+  let(:handler) { double 'handler' }
+
+  let :spec do
+    {:exchange => {:fake => "exchange_config"},
+     :queue    => {:fake => "queue_config"},
+     :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(:request_queue)     { double 'request_queue' }
+  let(:request_exchange)  { double 'request_exchange' }
+  let(:response_exchange) { double 'response_exchange' }
+
+  before do
+    allow(subject).to receive(:async).and_return(subject)
+
+    allow(declare).to receive(:queue).
+      with(:fake => "queue_config").and_return(request_queue)
+
+    allow(declare).to receive(:exchange).
+      with(:fake => "exchange_config").and_return(request_exchange)
+
+    allow(declare).to receive(:default_exchange).
+      and_return(response_exchange)
+
+    allow(declare).to receive(:bind).
+      with(request_queue, request_exchange, :fake => "bind_config")
+  end
+
+  let(:info)    { double 'info' }
+  let(:payload) { "some_data" }
+
+  let :meta do
+    double 'meta', :reply_to       => "reply.queue",
+                   :correlation_id => "123"
+  end
+
+  describe '#start' do
+    it 'declares and binds queue and exchange, and subscribes to the queue' do
+      expect(declare).to receive(:queue).
+        with(:fake => "queue_config").and_return(request_queue)
+
+      expect(declare).to receive(:exchange).
+        with(:fake => "exchange_config").and_return(request_exchange)
+
+      expect(declare).to receive(:default_exchange).
+        and_return(response_exchange)
+
+      expect(declare).to receive(:bind).
+        with(request_queue, request_exchange, :fake => "bind_config")
+
+      subscription_block = nil
+      expect(request_queue).to receive(:subscribe) do |opts, &block|
+        expect(opts).to eq :block => false, :manual_ack => false
+        subscription_block = block
+      end
+
+      subject.start
+
+      expect(subject).to receive(:handle).
+        with(meta, payload)
+
+      subscription_block.(info, meta, payload)
+    end
+  end
+
+  describe '#clean' do
+    it 'deletes queue and exchange' do
+      expect(request_queue    ).to receive(:delete)
+      expect(response_exchange).to receive(:delete)
+
+      subject.clean
+    end
+  end
+
+  describe '#handle' do
+    context 'on success' do
+      let(:response) { "some_response" }
+
+      it 'runs the handler with a callback 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.handle(meta, payload)
+
+        expect(subject).to receive(:reply).with(meta, "some_response", {})
+        callback.reply(response)
+      end
+    end
+
+    context 'on handler failure' do
+      let(:error) { double 'error' }
+
+      it 'calls failed on the server' do
+        error_block = nil
+        expect(handler).to receive :call do |payload, meta, callback, &block|
+          error_block = block
+        end
+
+        subject.handle(meta, payload)
+
+        expect(subject).to receive(:failed).
+          with(meta, error)
+
+        error_block.(error)
+      end
+    end
+  end
+
+  describe '#reply' do
+    let(:response) { "some_response" }
+
+    it 'delegates to the queue' do
+      expect(response_exchange).to receive(:publish).
+        with(response, :routing_key => "reply.queue", :correlation_id => "123")
+      subject.reply(meta, response)
+    end
+  end
+
+end

data/spec/liebre/adapter/bunny_spec.rb

@@ -0,0 +1,66 @@
+RSpec.describe Liebre::Adapter::Bunny do
+
+  subject { described_class.new }
+
+  describe '#connect and conn methods' do
+    let(:opts) { {:host => "localhost"} }
+
+    let(:common_opts) { {:auto_delete => true, :durable => false} }
+
+    it 'everything' do
+      # start a connection
+      #
+      conn    = subject.connection(opts)
+      session = conn.session
+
+      expect(conn.opts    ).to eq opts
+      expect(session.open?).to eq false
+
+      conn.start
+      expect(session.open?).to eq true
+
+      # open a channel
+      #
+      chan    = conn.open_channel
+      channel = chan.channel
+      expect(channel.open?).to eq true
+
+      # open an exchange, a queue and bind them
+      #
+      exchange = chan.exchange("foo", "fanout", common_opts)
+      queue    = chan.queue("bar", common_opts)
+      queue.bind(exchange)
+
+      # publish and get message, reject and ack
+      #
+      exchange.publish("some_data")
+
+      queue.get(:manual_ack => true) do |info, properties, payload|
+        expect(payload).to eq "some_data"
+
+        queue.reject(info, :requeue => true)
+      end
+
+      queue.get(:manual_ack => true) do |info, properties, payload|
+        expect(payload).to eq "some_data"
+
+        queue.ack(info, :requeue => true)
+      end
+
+      queue.get(:manual_ack => true) do |*args|
+        expect(args).to eq [nil, nil, nil]
+      end
+
+      # close a channel
+      #
+      chan.close
+      expect(channel.open?).to eq false
+
+      # stop a connection
+      #
+      conn.stop
+      expect(session.open?).to eq false
+    end
+  end
+
+end

data/spec/liebre/bridge_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe Liebre::Bridge do
+
+  let(:adapter) { double 'adapter' }
+
+  let(:name_1) { :foo }
+  let(:name_2) { :bar }
+  let(:opts_1) { double 'opts_1' }
+  let(:opts_2) { double 'opts_2' }
+
+  let(:connections) { {name_1 => opts_1, name_2 => opts_2}}
+
+  let(:logger) { double 'logger', :info => nil }
+
+  let :config do
+    double 'config', :adapter     => adapter,
+                     :connections => connections,
+                     :logger      => logger
+  end
+
+  subject { described_class.new(config) }
+
+  let(:conn_1) { double 'conn_1' }
+  let(:conn_2) { double 'conn_2' }
+
+  before do
+    allow(adapter).to receive(:connection).
+      with(opts_1).and_return(conn_1)
+
+    allow(adapter).to receive(:connection).
+      with(opts_2).and_return(conn_2)
+  end
+
+  describe '#open_channel' do
+    let(:chan) { double 'chan' }
+
+    let :chan_opts do
+      {:connection => name_2, :prefetch_count => 8}
+    end
+
+    it 'opens configured channels' do
+      expect(conn_1).to receive(:start)
+      expect(conn_2).to receive(:start)
+      subject.start
+
+      expect(conn_2).to receive(:open_channel).
+        and_return(chan)
+      expect(chan).to receive(:set_prefetch).
+        with(chan_opts[:prefetch_count])
+
+      expect(subject.open_channel(chan_opts)).to eq chan
+    end
+  end
+
+end