freddy-jruby 0.4.3

data/spec/freddy/consumer_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Freddy::Consumer do
+  let(:freddy) { Freddy.build(logger, config) }
+
+  let(:destination) { random_destination }
+  let(:payload)     { {pay: 'load'} }
+
+  let(:consumer) { freddy.consumer }
+
+  after { freddy.close }
+
+  it 'raises exception when no consumer is provided' do
+    expect { consumer.consume destination }.to raise_error described_class::EmptyConsumer
+  end
+
+  it "doesn't call passed block without any messages" do
+    consumer.consume destination do
+      @message_received = true
+    end
+    default_sleep
+
+    expect(@message_received).to be_falsy
+  end
+end

data/spec/freddy/error_response_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Freddy::ErrorResponse do
+  subject(:error) { described_class.new(input) }
+
+  context 'with an error type' do
+    let(:input) { {error: 'SomeError'} }
+
+    describe '#response' do
+      subject { error.response }
+
+      it { should eq(input) }
+    end
+
+    describe '#message' do
+      subject { error.message }
+
+      it 'uses error type as a message' do
+        should eq('SomeError')
+      end
+    end
+  end
+
+  context 'with an error type and message' do
+    let(:input) { {error: 'SomeError', message: 'extra info'} }
+
+    describe '#response' do
+      subject { error.response }
+
+      it { should eq(input) }
+    end
+
+    describe '#message' do
+      subject { error.message }
+
+      it 'uses error type as a message' do
+        should eq('SomeError: extra info')
+      end
+    end
+  end
+
+  context 'without an error type' do
+    let(:input) { {something: 'else'} }
+
+    describe '#response' do
+      subject { error.response }
+
+      it { should eq(input) }
+    end
+
+    describe '#message' do
+      subject { error.message }
+
+      it 'uses default error message as a message' do
+        should eq('Use #response to get the error response')
+      end
+    end
+  end
+end

data/spec/freddy/freddy_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+
+describe Freddy do
+  let(:freddy) { described_class.build(logger, config) }
+
+  let(:destination)  { random_destination }
+  let(:destination2) { random_destination }
+  let(:payload)      { {pay: 'load'} }
+
+  after { freddy.close }
+
+  def respond_to(&block)
+    freddy.respond_to(destination, &block)
+  end
+
+  context 'when making a send-and-forget request' do
+    context 'with timeout' do
+      it 'removes the message from the queue after the timeout' do
+        # Assume that there already is a queue. Otherwise will get an early
+        # return.
+        freddy.channel.queue(destination)
+
+        freddy.deliver(destination, {}, timeout: 0.1)
+        sleep 0.2
+
+        processed_after_timeout = false
+        respond_to { processed_after_timeout = true }
+        default_sleep
+
+        expect(processed_after_timeout).to be(false)
+      end
+    end
+
+    context 'without timeout' do
+      it 'keeps the message in the queue' do
+        # Assume that there already is a queue. Otherwise will get an early
+        # return.
+        freddy.channel.queue(destination)
+
+        freddy.deliver(destination, {})
+        default_sleep # to ensure everything is properly cleaned
+
+        processed_after_timeout = false
+        respond_to { processed_after_timeout = true }
+        default_sleep
+
+        expect(processed_after_timeout).to be(true)
+      end
+    end
+  end
+
+  context 'when making a synchronized request' do
+    it 'returns response as soon as possible' do
+      respond_to { |payload, msg_handler| msg_handler.success(res: 'yey') }
+      response = freddy.deliver_with_response(destination, {a: 'b'})
+
+      expect(response).to eq(res: 'yey')
+    end
+
+    it 'raises an error if the message was errored' do
+      respond_to { |payload, msg_handler| msg_handler.error(error: 'not today') }
+
+      expect {
+        freddy.deliver_with_response(destination, payload)
+      }.to raise_error(Freddy::InvalidRequestError) {|error|
+        expect(error.response).to eq(error: 'not today')
+      }
+    end
+
+    it 'does not leak consumers' do
+      respond_to { |payload, msg_handler| msg_handler.success(res: 'yey') }
+
+      old_count = freddy.channel.consumers.keys.count
+
+      response1 = freddy.deliver_with_response(destination, {a: 'b'})
+      response2 = freddy.deliver_with_response(destination, {a: 'b'})
+
+      expect(response1).to eq(res: 'yey')
+      expect(response2).to eq(res: 'yey')
+
+      new_count = freddy.channel.consumers.keys.count
+      expect(new_count).to be(old_count + 1)
+    end
+
+    it 'responds to the correct requester' do
+      respond_to { |payload, msg_handler| msg_handler.success(res: 'yey') }
+
+      response = freddy.deliver_with_response(destination, payload)
+      expect(response).to eq(res: 'yey')
+
+      expect {
+        freddy.deliver_with_response(destination2, payload)
+      }.to raise_error(Freddy::InvalidRequestError)
+    end
+
+    context 'when queue does not exist' do
+      it 'gives a no route error' do
+        begin
+          Timeout::timeout(0.5) do
+            expect {
+              freddy.deliver_with_response(destination, {a: 'b'}, timeout: 3)
+            }.to raise_error(Freddy::InvalidRequestError) {|error|
+              expect(error.response).to eq(error: 'Specified queue does not exist')
+            }
+          end
+        rescue Timeout::Error
+          fail('Received a timeout error instead of the no route error')
+        end
+      end
+    end
+
+    context 'on timeout' do
+      it 'gives timeout error' do
+        respond_to { |payload, msg_handler| sleep 0.2 }
+
+        expect {
+          freddy.deliver_with_response(destination, {a: 'b'}, timeout: 0.1)
+        }.to raise_error(Freddy::TimeoutError) {|error|
+          expect(error.response).to eq(error: 'RequestTimeout', message: 'Timed out waiting for response')
+        }
+      end
+
+      context 'with delete_on_timeout is set to true' do
+        it 'removes the message from the queue' do
+          # Assume that there already is a queue. Otherwise will get an early
+          # return.
+          freddy.channel.queue(destination)
+
+          expect {
+            freddy.deliver_with_response(destination, {}, timeout: 0.1)
+          }.to raise_error(Freddy::TimeoutError)
+          default_sleep # to ensure everything is properly cleaned
+
+          processed_after_timeout = false
+          respond_to { processed_after_timeout = true }
+          default_sleep
+
+          expect(processed_after_timeout).to be(false)
+        end
+      end
+
+      context 'with delete_on_timeout is set to false' do
+        it 'removes the message from the queue' do
+          # Assume that there already is a queue. Otherwise will get an early
+          # return.
+          freddy.channel.queue(destination)
+
+          expect {
+            freddy.deliver_with_response(destination, {}, timeout: 0.1, delete_on_timeout: false)
+          }.to raise_error(Freddy::TimeoutError)
+          default_sleep # to ensure everything is properly cleaned
+
+          processed_after_timeout = false
+          respond_to { processed_after_timeout = true }
+          default_sleep
+
+          expect(processed_after_timeout).to be(true)
+        end
+      end
+    end
+  end
+
+  describe 'when tapping' do
+    def tap(custom_destination = destination, &block)
+      freddy.tap_into(custom_destination, &block)
+    end
+
+    it 'receives messages' do
+      tap {|msg| @tapped_message = msg }
+      deliver
+
+      wait_for { @tapped_message }
+      expect(@tapped_message).to eq(payload)
+    end
+
+    it 'has the destination' do
+      tap "somebody.*.love" do |message, destination|
+        @destination = destination
+      end
+      deliver "somebody.to.love"
+
+      wait_for { @destination }
+      expect(@destination).to eq("somebody.to.love")
+    end
+
+    it "doesn't consume the message" do
+      tap { @tapped = true }
+      respond_to { @message_received = true }
+
+      deliver
+
+      wait_for { @tapped }
+      wait_for { @message_received }
+      expect(@tapped).to be(true)
+      expect(@message_received).to be(true)
+    end
+
+    it "allows * wildcard" do
+      tap("somebody.*.love") { @tapped = true }
+
+      deliver "somebody.to.love"
+
+      wait_for { @tapped }
+      expect(@tapped).to be(true)
+    end
+
+    it "* matches only one word" do
+      tap("somebody.*.love") { @tapped = true }
+
+      deliver "somebody.not.to.love"
+
+      default_sleep
+      expect(@tapped).to be_falsy
+    end
+
+    it "allows # wildcard" do
+      tap("i.#.free") { @tapped = true }
+
+      deliver "i.want.to.break.free"
+
+      wait_for { @tapped }
+      expect(@tapped).to be(true)
+    end
+  end
+end

data/spec/freddy/message_handler_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Freddy::MessageHandler do
+  subject(:handler) { described_class.new(adapter, delivery) }
+
+  let(:adapter) { double }
+  let(:delivery) { double(metadata: metadata) }
+  let(:metadata) { double(reply_to: reply_to, correlation_id: 'abc') }
+
+  let(:reply_to) { double }
+
+  describe '#success' do
+    it 'delegates to the adapter' do
+      expect(adapter).to receive(:success).with(reply_to, x: 'y')
+
+      subject.success(x: 'y')
+    end
+  end
+
+  describe '#error' do
+    it 'delegates to the adapter' do
+      expect(adapter).to receive(:error).with(reply_to, error: 'text')
+
+      subject.error(error: 'text')
+    end
+  end
+end

data/spec/freddy/request_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Freddy::Request do
+  let(:freddy) { Freddy.build(logger, config) }
+
+  let(:destination) { random_destination }
+  let(:payload)     { {pay: 'load'} }
+
+  let(:request) { freddy.request }
+
+  after { freddy.close }
+
+  it 'raises empty responder exception when responding without callback' do
+    expect {@responder = request.respond_to destination }.to raise_error described_class::EmptyResponder
+  end
+
+  context 'requesting from multiple threads' do
+    let(:nr_of_threads) { 50 }
+
+    before do
+      freddy.respond_to 'thread-queue' do |payload, msg_handler|
+        msg_handler.success(payload)
+      end
+    end
+
+    it 'handles multiple threads' do
+      require 'hamster/experimental/mutable_set'
+      msg_counter = Hamster.mutable_set
+      nr_of_threads.times.map do |index|
+        Thread.new do
+          response = freddy.deliver_with_response 'thread-queue', payload
+          msg_counter << index
+          expect(response).to eq(payload)
+        end
+      end.each(&:join)
+      expect(msg_counter.count).to eq(nr_of_threads)
+    end
+
+  end
+
+end

data/spec/freddy/responder_handler_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Freddy::ResponderHandler do
+  let(:freddy) { Freddy.build(logger, config) }
+
+  let(:destination) { random_destination }
+  let(:payload)     { {pay: 'load'} }
+
+  after { freddy.close }
+
+  it 'can cancel listening for messages' do
+    consumer_handler = freddy.respond_to destination do
+      @messages_count ||= 0
+      @messages_count += 1
+    end
+    deliver
+    consumer_handler.cancel
+    deliver
+
+    expect(@messages_count).to eq 1
+  end
+end

data/spec/integration/concurrency_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe 'Concurrency' do
+  let(:freddy1) { Freddy.build(logger, config) }
+  let(:freddy2) { Freddy.build(logger, config) }
+  let(:freddy3) { Freddy.build(logger, config) }
+
+  after { [freddy1, freddy2, freddy3].each(&:close) }
+
+  it 'supports multiple requests in #respond_to' do
+    freddy1.respond_to 'Concurrency1' do |payload, msg_handler|
+      begin
+        freddy1.deliver_with_response 'Concurrency2', msg: 'noop'
+        result2 = freddy1.deliver_with_response 'Concurrency3', msg: 'noop'
+        msg_handler.success(result2)
+      rescue Freddy::InvalidRequestError => e
+        msg_handler.error(e.response)
+      end
+    end
+
+    freddy2.respond_to 'Concurrency2' do |payload, msg_handler|
+      begin
+        msg_handler.success({from: 'Concurrency2'})
+      rescue Freddy::InvalidRequestError => e
+        msg_handler.error(e.response)
+      end
+    end
+
+    freddy3.respond_to 'Concurrency3' do |payload, msg_handler|
+      msg_handler.success({from: 'Concurrency3'})
+    end
+
+    result =
+      begin
+        freddy1.deliver_with_response 'Concurrency1', msg: 'noop'
+      rescue Freddy::InvalidRequestError => e
+        e.response
+      end
+
+    expect(result).to eq(from: 'Concurrency3')
+  end
+
+  it 'supports nested calls in #tap_into' do
+    received1 = false
+    received2 = false
+
+    freddy1.tap_into 'concurrency.*.queue1' do
+      result = freddy1.deliver_with_response 'TapConcurrency', msg: 'noop'
+      expect(result).to eq(from: 'TapConcurrency')
+      received1 = true
+    end
+
+    freddy2.respond_to 'TapConcurrency' do |payload, msg_handler|
+      msg_handler.success({from: 'TapConcurrency'})
+      received2 = true
+    end
+
+    freddy1.deliver 'concurrency.q.queue1', msg: 'noop'
+
+    wait_for { received1 && received2 }
+
+    expect(received1).to be(true)
+    expect(received2).to be(true)
+  end
+end