liebre 0.1.3

data/spec/liebre/publisher_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+RSpec.describe Liebre::Publisher do
+
+  let :exchange_config do
+    { 
+      'name' => "test_exchange",
+      'type' => "direct",
+      'opts' => {
+        'durable' => false
+      }
+    }
+  end
+  
+  let :publishers_config do
+    { 
+      'test_publisher' => {
+        'exchange' =>
+          exchange_config 
+      }
+    }
+  end
+  
+  let(:channel)            { double 'channel' }
+  let(:bunny_connection)   { double 'bunny_conection',    :create_channel => channel }
+  let(:connection_manager) { double 'connection_manager', :get => bunny_connection }
+  let(:exchange)           { double 'exchange' }
+  
+  before do
+    allow_any_instance_of(Liebre::Config).to receive(:publishers).and_return publishers_config
+    allow_any_instance_of(Liebre::Config).to receive(:rpc_request_timeout).and_return 10
+    
+    expect(Liebre::ConnectionManager).to receive(:new).and_return connection_manager
+    expect(connection_manager).to receive(:ensure_started)
+    
+    expect(Liebre::Common::Utils).to receive(:create_exchange).
+      with(channel, exchange_config).and_return exchange
+    
+  end
+  
+  subject { described_class.new 'test_publisher' }
+  
+  describe "#enqueue" do
+    it do
+      message = "abc"
+      expect(exchange).to receive(:publish).with message, {}
+    
+      subject.enqueue message
+    end
+  end
+  
+  describe "#enqueue_and_wait" do
+    
+    let(:correlation_id)   { "correlation_id" }
+    let(:reply_queue_name) { "test_publisher_callback_#{correlation_id}" }
+    let(:reply_queue)      { double "reply_queue", :name => reply_queue_name }
+    let(:delivery_info)    { double "delivery_info", :consumer_tag => "tag"}
+    let(:consumer)         { double 'consumer' }
+    let(:consumers)        { {"tag" => consumer} }
+    
+    before do
+      expect(channel).to receive(:queue).with(reply_queue_name, :exclusive => true).
+        and_return reply_queue
+    end
+    
+    it do
+      message = "question"
+      answer = "answer"
+      expect(exchange).to receive(:publish).with message, 
+        {:correlation_id => correlation_id, :reply_to => reply_queue_name}
+      
+      expect(reply_queue).to receive(:subscribe).with(:block => true) do |&block|
+        expect(channel).to receive(:consumers).and_return consumers
+        expect(consumer).to receive(:cancel)
+        
+        block.call(delivery_info, {:correlation_id => correlation_id}, answer)
+      end
+      
+      expect(reply_queue).to receive(:delete)
+    
+      result = subject.enqueue_and_wait message, :correlation_id => correlation_id
+      expect(result).to eq answer
+    end
+  end
+  
+end

data/spec/liebre/runner/consumers_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe Liebre::Runner::Consumers do
+
+  let(:conn) { double 'conn' }
+
+  let(:first_expected_config)  do 
+    {
+      "class_name" => "MyConsumer",
+      "num_threads" => 3,
+      "rpc" => false
+    } 
+  end
+    
+  let(:second_expected_config) do 
+    {
+      "class_name" => "MyRPC",
+      "rpc" => true
+    }
+  end
+  
+  let(:consumers_config) do 
+    {
+      "some_consumer" => first_expected_config,
+      "some_rpc" => second_expected_config
+    }
+  end
+    
+  before do
+    allow(subject).to receive(:consumers).and_return consumers_config
+  end
+
+  subject { described_class.new(conn) }
+
+  describe "#consumer_names" do
+    it "returns all names" do
+      expect(subject.consumer_names).to eq ["some_consumer", "some_rpc"]
+    end
+  end
+
+  describe "#start_all" do
+    let(:first_starter)  { double 'first_starter' }
+    let(:second_starter) { double 'second_starter' }
+
+    it "starts the given consumers" do
+      expect(Liebre::Runner::Starter).to receive(:new).exactly(3).times.
+        with(conn, first_expected_config).and_return(first_starter)
+
+      expect(Liebre::Runner::Starter).to receive(:new).
+        with(conn, second_expected_config).and_return(second_starter)
+
+      expect(first_starter ).to receive(:call).exactly(3).times
+      expect(second_starter).to receive(:call)
+
+      subject.start_all
+    end
+  end
+
+end

data/spec/liebre/runner/starter/consumer_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+RSpec.describe Liebre::Runner::Starter::Consumer do
+
+  let(:connection) { double 'connection' }
+  
+  let(:class_name) { "MyConsumer" }
+  let(:pool_size)  { 4 }
+
+  let :config do
+    {
+      "class_name" => class_name,
+      "pool_size"  => pool_size,
+      "rpc" => false,
+      "exchange" => {
+        "name" => "test_exchange",
+        "type" => "direct",
+        "opts" => {
+          "durable" => true
+        }
+      },
+      "queue" => {
+        "name" => "test_queue",
+        "opts" => {
+          "durable" => true
+        }        
+      }
+    }
+  end
+
+  let :error_config do
+    {
+      "class_name" => class_name,
+      "pool_size"  => pool_size,
+      "rpc" => false,
+      "exchange" => {
+        "name" => "test_exchange-error",
+        "type" => "direct",
+        "opts" => {
+          "durable" => true
+        }
+      },
+      "queue" => {
+        "name" => "test_queue-error",
+        "opts" => {
+          "durable" => true,
+          "exclusive" => true
+        }        
+      }
+    }
+  end
+
+  let :parsed_config do
+    {
+      "class_name" => class_name,
+      "pool_size"  => pool_size,
+      "rpc" => false,
+      "exchange" => {
+        "name" => "test_exchange",
+        "type" => "direct",
+        "opts" => {
+          "durable" => true
+        }
+      },
+      "queue" => {
+        "name" => "test_queue",
+        "opts" => {
+          "durable" => true,
+          "arguments" => {
+            'x-dead-letter-exchange' => "test_exchange-error"
+          }
+        }        
+      }
+    }
+  end
+
+  let(:exchange)    { double 'exchange' }
+  let(:queue)       { double 'queue' }
+  let(:error_queue) { double 'error_queue' }
+  let(:channel)     { double 'channel' }
+  let(:payload)     { "the_payload" }
+
+  subject { described_class.new(connection, config) }
+
+  let :resources do
+    double 'resources', :exchange => exchange, :queue => queue, :channel => channel
+  end
+  
+  let :error_resources do
+    double 'resources', :queue => error_queue
+  end
+    
+  let(:class_name) { "MyConsumer" }
+
+  let(:consumer_class)    { double 'consumer_class', :name => 'consumer_class' }
+  let(:consumer_instance) { double 'consumer_instance' }
+    
+  let :meta do
+    double 'meta'
+  end
+  
+  let(:handler) { double 'handler' }
+  
+  let(:deliver_info) { double 'deliver_info' }
+  let(:ack) { :ack }
+
+  before do
+    expect(Liebre::Runner::Starter::Resources).to receive(:new).
+      with(connection, error_config).and_return(error_resources)
+    
+    expect(Liebre::Runner::Starter::Resources).to receive(:new).
+      with(connection, parsed_config).and_return(resources)
+
+    stub_const(class_name, consumer_class)
+    
+    expect(described_class::Handler).to receive(:new).
+      with(channel).and_return handler
+  end
+
+  it 'creates error queue and creates and subscribes to standard queue' do
+    
+    expect(queue).to receive :subscribe do |&block|
+      block.call(deliver_info, meta, payload)
+    end
+
+    expect(consumer_class).to receive :new do |given_payload, given_meta|
+      expect(given_payload).to eq payload
+      expect(given_meta   ).to eq meta
+
+      consumer_instance
+    end
+
+    expect(consumer_instance).to receive(:call).and_return ack
+    
+    expect(handler).to receive(:respond).with ack, deliver_info
+
+    subject.call
+  end
+    
+end

data/spec/liebre/runner/starter/resources/queue_builder_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+RSpec.describe Liebre::Runner::Starter::Resources::QueueBuilder do
+
+  let(:channel) { double 'channel' }
+  let(:routing_key) { "foo" }
+
+  let :config do
+    {
+      "queue" => {
+        "name" => "my_queue",
+        "opts" => {"some" => "option"}
+      },
+      "exchange" => {
+        "name" => "my_exchange",
+        "type" => "direct",
+        "opts" => {"an" => "option"}
+      },
+      "bind" => {"routing_key" => routing_key}
+    }
+  end
+  
+  let(:exchange) { double 'exchange' }
+  let(:queue)    { double 'queue' }
+
+  subject { described_class.new(channel, config) }
+
+  describe '#call' do
+
+    it 'builds and binds the queue properly' do
+      expect(channel).to receive(:exchange).
+        with("my_exchange", :type => "direct", :an => "option").
+        and_return(exchange)
+
+      expect(channel).to receive(:queue).
+        with("my_queue", :some => "option").
+        and_return(queue)
+
+      expect(queue).to receive(:bind).
+        with(exchange, :routing_key => "foo")
+
+      expect(subject.queue).to eq queue
+    end
+  end
+  
+  describe "with multiple routing_keys" do
+    let(:routing_key) { %W{a b c} }
+    
+    it 'builds and binds the queue properly' do
+      allow(channel).to receive(:exchange).
+        with("my_exchange", :type => "direct", :an => "option").
+        and_return(exchange)
+
+      expect(channel).to receive(:queue).
+        with("my_queue", :some => "option").
+        and_return(queue)
+
+      expect(queue).to receive(:bind).
+        with(exchange, :routing_key => "a")
+      expect(queue).to receive(:bind).
+        with(exchange, :routing_key => "b")
+      expect(queue).to receive(:bind).
+        with(exchange, :routing_key => "c")
+
+      expect(subject.queue).to eq queue
+    end
+  end
+
+end

data/spec/liebre/runner/starter/resources_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+RSpec.describe Liebre::Runner::Starter::Resources do
+
+  let(:connection) { double 'connection' }
+
+  let(:pool_size) { 4 }
+  let(:config)    { {"pool_size"  => pool_size} }
+
+  subject { described_class.new(connection, config) }
+
+  describe '#exchange and #queue' do
+    let(:channel)     { double 'channel' }
+    let(:exchange) { double 'exchange' }
+
+    let(:queue)         { double 'queue' }
+    let(:queue_builder) { double 'queue_builder', :queue => queue, :exchange => exchange }
+
+    before do
+      allow(connection).to receive(:create_channel).
+        with(nil, pool_size).and_return(channel)
+
+      allow(channel).to receive(:default_exchange).
+        and_return(exchange)
+
+      allow(described_class::QueueBuilder).to receive(:new).
+        with(channel, config).and_return(queue_builder)
+    end
+
+    it 'builds exchange and queue properly' do
+      expect(subject.exchange).to eq exchange
+      expect(subject.queue   ).to eq queue
+    end
+  end
+
+end

data/spec/liebre/runner/starter/rpc_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+RSpec.describe Liebre::Runner::Starter::RPC do
+
+  let(:connection) { double 'connection' }
+  
+  let(:class_name) { "MyRPC" }
+  let(:pool_size)  { 4 }
+
+  let :config do
+    {
+      "class_name" => class_name,
+      "pool_size"  => pool_size,
+      "rpc" => true,
+      "exchange" => {
+        "name" => "test_exchange",
+        "type" => "direct",
+        "opts" => {
+          "durable" => false
+        }
+      },
+      "queue" => {
+        "name" => "test_queue",
+        "opts" => {
+          "durable" => false
+        }        
+      }
+    }
+  end
+
+  let(:exchange) { double 'exchange' }
+  let(:queue)    { double 'queue' }
+  let(:channel)  { double 'channel', :default_exchange => exchange }
+  let(:payload)  { "the_payload" }
+  let(:response) { "the_response" }
+
+  subject { described_class.new(connection, config) }
+
+  let :resources do
+    double 'resources', :exchange => exchange, :queue => queue, :channel => channel
+  end
+    
+  let(:class_name) { "MyConsumer" }
+
+  let(:rpc_class)    { double 'rpc_class', :name => 'rpc_class' }
+  let(:rpc_instance) { double 'rpc_instance' }
+    
+  let(:reply_to)       { "queue_to_reply_to" }
+  let(:correlation_id) { 123 }
+  let :meta do
+    double 'meta', 
+      :reply_to       => reply_to,
+      :correlation_id => correlation_id
+  end
+  
+  let :opts do
+    {:routing_key => reply_to, :correlation_id => correlation_id}
+  end
+  
+  let(:handler) { double 'handler' }
+  
+  let(:deliver_info) { double 'deliver_info' }
+
+  before do
+    allow(Liebre::Runner::Starter::Resources).to receive(:new).
+      with(connection, config).and_return(resources)
+
+    stub_const(class_name, rpc_class)
+  end
+
+  it 'creates error queue and creates and subscribes to standard queue' do
+    
+    expect(exchange).to receive(:publish).with(response, opts)
+      
+    expect(queue).to receive :subscribe do |&block|
+      block.call(deliver_info, meta, payload)
+    end
+
+    expect(rpc_class).to receive :new do |given_payload, given_meta, callback|
+      expect(given_payload).to eq payload
+      expect(given_meta   ).to eq meta
+      callback.call(response)
+
+      rpc_instance
+    end
+
+    expect(rpc_instance).to receive(:call)
+
+    subject.call
+  end
+    
+end