liebre 0.1.21 → 0.2.1

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

@@ -1,145 +0,0 @@
-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
-        }        
-      }
-    }
-  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', :name => "queue" }
-  let(:error_queue) { double 'error_queue' }
-  let(:channel)     { double 'channel' }
-  let(:consumer)    { double 'consumer' }
-  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)
-      consumer
-    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.start
-    
-    expect(consumer).to receive(:cancel)
-    expect(channel).to receive(:close)
-    subject.stop
-  end
-    
-end

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

@@ -1,69 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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(:prefetch).with(10)
-
-      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

@@ -1,100 +0,0 @@
-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', :name => "queue" }
-  let(:channel)  { double 'channel', :default_exchange => exchange }
-  let(:consumer) { double 'consumer' }
-  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(:headers)        { {} }
-  let :meta do
-    double 'meta', 
-      :reply_to       => reply_to,
-      :correlation_id => correlation_id,
-      :headers        => headers
-  end
-  
-  let :opts do
-    {:routing_key => reply_to, :correlation_id => correlation_id, :headers => headers}
-  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)
-      consumer
-    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.start
-    
-    expect(consumer).to receive(:cancel)
-    expect(channel).to receive(:close)
-    subject.stop
-  end
-    
-end

data/spec/liebre/runner/starter_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Liebre::Runner::Starter do
-
-  let(:connection_manager) { double 'connection_manager' }
-  let(:connection)         { double 'connection' }
-    let(:consumer)         { double 'consumer' }
-  
-  let(:rpc) { true }
-
-  let :config do
-    {
-      "rpc" => rpc,
-      "connection_name" => "rpc"
-    }
-  end
-  
-  subject { described_class.new(connection_manager, config) }
-  
-  context "RPC" do
-    
-    let(:rpc_instance) { double 'rpc_instance' }
-
-    describe '#start and #stop' do
-      
-      it 'calls the rpc_class with a callback' do
-        expect(connection_manager).to receive(:get).with(:rpc).and_return connection
-        expect(described_class::RPC).to receive(:new).with(connection, config).and_return rpc_instance
-        expect(rpc_instance).to receive(:start).and_return consumer
-
-        subject.start
-        
-        expect(consumer).to receive(:stop)
-        
-        subject.stop
-        
-      end
-    end
-  end
-  
-  context "Standard Consumer" do
-    
-    let(:rpc) { false }
-    
-    let(:consumer) { double 'consumer' }
-
-    let :config do
-      {
-        "rpc" => rpc
-      }
-    end
-
-    describe '#start and #stop' do
-      
-      it 'calls the rpc_class with a callback' do
-        expect(connection_manager).to receive(:get).with(:default).and_return connection
-        expect(described_class::Consumer).to receive(:new).with(connection, config).and_return consumer
-        expect(consumer).to receive(:start).and_return consumer
-
-        subject.start
-        
-        expect(consumer).to receive(:stop)
-        
-        subject.stop
-        
-      end
-    end
-    
-  end
-end

data/spec/liebre/runner_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Liebre::Runner do
-    
-  let :connection_path do
-    File.expand_path("../../config/rabbitmq.yml" ,__FILE__)
-  end
-
-  let(:interval) { 1234 }
-
-  subject { described_class.new(interval) }
-  let(:logger) { double 'logger' }
-
-  let(:connection_manager) { double 'connection_manager'}
-
-  let(:consumers) { double 'consumers' }
-
-  before do
-    Liebre::Config.connection_path = connection_path
-    
-    allow(subject).to receive(:logger).
-      and_return(logger)
-
-    allow(Liebre::ConnectionManager).to receive(:instance).
-      and_return(connection_manager)
-
-    allow(described_class::Consumers).to receive(:new).
-      with(connection_manager).and_return(consumers)
-  end
-
-  describe '#run' do
-    it 'logs and retries after fail' do
-      expect(connection_manager).to receive(:restart) do
-        raise "some error"
-      end
-
-      expect(logger).to receive(:warn) do |error|
-        expect(error.message).to match /some error/
-      end
-      expect(subject).to receive(:sleep).with(interval)
-      expect(logger).to receive(:warn) do |message|
-        expect(message).to match /Retrying/
-      end
-
-      expect(connection_manager).to receive(:restart)
-      expect(consumers   ).to receive(:start_all)
-
-      expect(subject).to receive(:sleep)
-
-      subject.start
-    end
-  end
-  
-end