action_subscriber 1.0.3-java

data/spec/lib/action_subscriber/dsl_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe ::ActionSubscriber::DSL do
+  let(:subscriber) { Object.new }
+  before { subscriber.extend(::ActionSubscriber::DSL) }
+
+  describe "acknowledging messages" do
+    context "when manual_acknowledgement! is set" do
+      before { subscriber.manual_acknowledgement! }
+
+      it "acknowledges messages" do
+        expect(subscriber.acknowledge_messages?).to eq(true)
+      end
+
+      it "returns expected queue subscription options" do
+        expect(subscriber.queue_subscription_options).to eq( :manual_ack => true )
+      end
+
+      it "does not acknowledge messages after processing them" do
+        expect(subscriber.acknowledge_messages_after_processing?).to eq(false)
+      end
+
+      it "does not acknowledge messages before processing them" do
+        expect(subscriber.acknowledge_messages_before_processing?).to eq(false)
+      end
+    end
+
+    context "when at_most_once! is set" do
+      before { subscriber.at_most_once! }
+
+      it "acknowledges messages" do
+        expect(subscriber.acknowledge_messages?).to eq(true)
+      end
+
+      it "acknowledges messages before processing them" do
+        expect(subscriber.acknowledge_messages_before_processing?).to eq(true)
+      end
+
+      it "does not acknowledge messages after processing them" do
+        expect(subscriber.acknowledge_messages_after_processing?).to eq(false)
+      end
+    end
+
+    context "when at_least_once! is set" do
+      before { subscriber.at_least_once! }
+
+      it "acknowledges messages" do
+        expect(subscriber.acknowledge_messages?).to eq(true)
+      end
+
+      it "does not acknowledge messages before processing them" do
+        expect(subscriber.acknowledge_messages_before_processing?).to eq(false)
+      end
+
+      it "acknowledges messages after processing them" do
+        expect(subscriber.acknowledge_messages_after_processing?).to eq(true)
+      end
+    end
+
+    context "when no_acknowledgement! is set" do
+      before { subscriber.no_acknowledgement! }
+
+      it "does not acknowledge messages" do
+        expect(subscriber.acknowledge_messages?).to eq(false)
+      end
+
+      it "does not acknowledge messages after processing them" do
+        expect(subscriber.acknowledge_messages_after_processing?).to eq(false)
+      end
+
+      it "does not acknowledge messages before processing them" do
+        expect(subscriber.acknowledge_messages_before_processing?).to eq(false)
+      end
+    end
+
+    context "default" do
+      it "does not acknowledge messages" do
+        expect(subscriber.acknowledge_messages?).to eq(false)
+      end
+
+      it "does not acknowledge messages after processing them" do
+        expect(subscriber.acknowledge_messages_after_processing?).to eq(false)
+      end
+
+      it "does not acknowledge messages before processing them" do
+        expect(subscriber.acknowledge_messages_before_processing?).to eq(false)
+      end
+    end
+  end
+
+  describe "exchange_names" do
+    context "when exchange names are set" do
+      before { subscriber.exchange_names :foo, :bar }
+
+      it "returns an array of exchange names" do
+        expect(subscriber.exchange_names).to eq(["foo", "bar"])
+      end
+    end
+
+    context "when exchange names are not set" do
+      before { subscriber.instance_variable_set(:@_exchange_names, nil) }
+
+      it "returns the default exchange" do
+        expect(subscriber.exchange_names).to eq(["events"])
+      end
+    end
+  end
+
+  describe "queue_for" do
+    before { subscriber.queue_for(:created, "my_app.app.user.created") }
+
+    it "adds the method and queue name to the queue names collection" do
+      expect(subscriber.queue_names).to eq({:created => "my_app.app.user.created" })
+    end
+  end
+
+  describe "remote_application_name" do
+    context "when remote appliation name is set" do
+      before { subscriber.remote_application_name "app" }
+
+      it "returns the remote application name" do
+        expect(subscriber.remote_application_name).to eq("app")
+      end
+    end
+
+    context "when remote application name is not set" do
+      before { subscriber.instance_variable_set(:@_remote_application_name, nil) }
+
+      it "returns nil" do
+        expect(subscriber.remote_application_name).to be_nil
+      end
+    end
+  end
+
+  describe "routing_key_for" do
+    before { subscriber.routing_key_for(:created, "app.user.created") }
+
+    it "adds the method name to the routing key names collection" do
+      expect(subscriber.routing_key_names).to eq({:created => "app.user.created"})
+    end
+  end
+
+end

data/spec/lib/action_subscriber/middleware/active_record/connection_management_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'action_subscriber/middleware/active_record/connection_management'
+
+describe ActionSubscriber::Middleware::ActiveRecord::ConnectionManagement do
+  include_context 'action subscriber middleware env'
+
+  before { allow(ActiveRecord::Base).to receive(:clear_active_connections!) }
+
+  subject { described_class.new(app) }
+
+  it_behaves_like 'an action subscriber middleware'
+
+  it "clears active connections" do
+    expect(ActiveRecord::Base).to receive(:clear_active_connections!)
+    subject.call(env)
+  end
+end

data/spec/lib/action_subscriber/middleware/active_record/query_cache_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'action_subscriber/middleware/active_record/query_cache'
+
+describe ActionSubscriber::Middleware::ActiveRecord::QueryCache do
+  include_context 'action subscriber middleware env'
+
+  let(:connection) { double(:connection, :query_cache_enabled => true) }
+
+  before do
+    allow(connection).to receive(:clear_query_cache)
+    allow(connection).to receive(:disable_query_cache!)
+    allow(connection).to receive(:enable_query_cache!)
+
+    allow(ActiveRecord::Base).to receive(:connection).and_return(connection)
+    allow(ActiveRecord::Base).to receive(:connection_id)
+  end
+
+  subject { described_class.new(app) }
+
+  it_behaves_like 'an action subscriber middleware'
+
+  it "enables the query cache" do
+    expect(connection).to receive(:enable_query_cache!)
+    subject.call(env)
+  end
+
+  it "clears the query cache" do
+    expect(connection).to receive(:clear_query_cache)
+    subject.call(env)
+  end
+
+  context "when the query cache is already enabled" do
+    before { allow(connection).to receive(:query_cache_enabled).and_return(true) }
+
+    it "does not disable the query cache" do
+      expect(connection).to_not receive(:disable_query_cache!)
+      subject.call(env)
+    end
+  end
+
+  context "when the query cache is not already enabled" do
+    before { allow(connection).to receive(:query_cache_enabled).and_return(false) }
+
+    it "does disable the query cache" do
+      expect(connection).to receive(:disable_query_cache!)
+      subject.call(env)
+    end
+  end
+end

data/spec/lib/action_subscriber/middleware/decoder_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe ActionSubscriber::Middleware::Decoder do
+  include_context 'action subscriber middleware env'
+
+  subject { described_class.new(app) }
+
+  it_behaves_like 'an action subscriber middleware'
+
+  let(:env) { ActionSubscriber::Middleware::Env.new(UserSubscriber, encoded_payload, message_properties) }
+  let(:encoded_payload) { JSON.generate(payload) }
+  let(:payload) { {"ohai" => "GUYZ"} }
+
+  context "when the content type has an associated decoder" do
+    before { message_properties[:content_type] = "application/json"}
+
+    it "decodes the payload" do
+      subject.call(env)
+      expect(env.payload).to eq(payload)
+    end
+  end
+
+  context "when the content type does not have an associated decoder" do
+    before { message_properties[:content_type] = "application/foo"}
+
+    it "uses the payload as-is" do
+      subject.call(env)
+      expect(env.payload).to eq(encoded_payload)
+    end
+  end
+end

data/spec/lib/action_subscriber/middleware/env_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe ActionSubscriber::Middleware::Env do
+  let(:channel) { double("channel") }
+  let(:encoded_payload) { 'encoded_payload' }
+  let(:properties){ {
+    :channel => channel,
+    :content_type => "application/json",
+    :delivery_tag => "XYZ",
+    :encoded_payload => encoded_payload,
+    :exchange => "events",
+    :message_id => "MSG-1234",
+    :routing_key => "amigo.user.created",
+  } }
+  let(:subscriber) { UserSubscriber }
+
+  subject { described_class.new(subscriber, encoded_payload, properties) }
+
+  specify { expect(subject.action).to eq("created") }
+  specify { expect(subject.content_type).to eq(properties[:content_type]) }
+  specify { expect(subject.exchange).to eq(properties[:exchange]) }
+  specify { expect(subject.message_id).to eq(properties[:message_id]) }
+  specify { expect(subject.routing_key).to eq(properties[:routing_key]) }
+
+  describe "#acknowledge" do
+    it "sends an acknowledgement to rabbitmq" do
+      expect(channel).to receive(:ack).with(properties[:delivery_tag], false)
+      subject.acknowledge
+    end
+  end
+
+  describe "#reject" do
+    it "sends an rejection to rabbitmq" do
+      expect(channel).to receive(:reject).with(properties[:delivery_tag], true)
+      subject.reject
+    end
+  end
+
+  describe "#to_hash" do
+    it "includes the action" do
+      expect(subject.to_hash).to have_key(:action)
+    end
+
+    it "includes the content_type" do
+      expect(subject.to_hash).to have_key(:content_type)
+    end
+
+    it "includes the exchange" do
+      expect(subject.to_hash).to have_key(:exchange)
+    end
+
+    it "includes the routing_key" do
+      expect(subject.to_hash).to have_key(:routing_key)
+    end
+
+    it "includes the payload" do
+      expect(subject.to_hash).to have_key(:payload)
+    end
+  end
+end

data/spec/lib/action_subscriber/middleware/error_handler_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'action_subscriber/middleware/error_handler'
+
+describe ActionSubscriber::Middleware::ErrorHandler do
+  include_context 'action subscriber middleware env'
+
+  subject { described_class.new(app) }
+
+  it_behaves_like 'an action subscriber middleware'
+
+  let(:error) { ::RuntimeError.new("Boom!") }
+
+  context "when an exception occurs" do
+    before { allow(app).to receive(:call).and_raise(error) }
+
+    it "calls the exception handler" do
+      handler = ::ActionSubscriber.configuration.error_handler
+      expect(handler).to receive(:call).with(error, env.to_h)
+
+      subject.call(env)
+    end
+
+    context "when the subscriber was expecting to acknowledge the message" do
+      before { allow(env.subscriber).to receive(:acknowledge_messages_after_processing?).and_return(true) }
+
+      it "calls the exception handler and rejects the message" do
+        handler = ::ActionSubscriber.configuration.error_handler
+        expect(handler).to receive(:call).with(error, env.to_h)
+        expect(env).to receive(:reject).with(no_args)
+
+        subject.call(env)
+      end
+    end
+  end
+end

data/spec/lib/action_subscriber/middleware/router_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe ActionSubscriber::Middleware::Router do
+  include_context 'action subscriber middleware env'
+
+  subject { described_class.new(app) }
+
+  it "routes the event to the proper action" do
+    allow_any_instance_of(env.subscriber).to receive(env.action)
+    subject.call(env)
+  end
+
+  it "acknowledges messages after processing if the subscriber flag is set" do
+    allow(env.subscriber).to receive(:acknowledge_messages_after_processing?).and_return(true)
+    expect(env).to receive(:acknowledge)
+    subject.call(env)
+  end
+
+  it "acknowledges messages before processing if the subscriber flag is set" do
+    allow(env.subscriber).to receive(:acknowledge_messages_before_processing?).and_return(true)
+    expect(env).to receive(:acknowledge)
+    subject.call(env)
+  end
+end

data/spec/lib/action_subscriber/middleware/runner_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe ActionSubscriber::Middleware::Runner do
+  # TODO: Figure out at way to test this...
+  it "adds the router to the top of the stack"
+end

data/spec/lib/action_subscriber/subscribable_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+TestSubscriber = Class.new(ActionSubscriber::Base) do
+  def updated
+  end
+
+  def updated_low
+  end
+end
+TestSubscriber.remote_application_name :bob
+
+describe ActionSubscriber::Subscribable do
+  describe "allow_low_priority_methods?" do
+    after do
+      ::ActionSubscriber.configure { |config| config.allow_low_priority_methods = false }
+    end
+
+    it "when the configuration is false is is false" do
+      ::ActionSubscriber.configure { |config| config.allow_low_priority_methods = false }
+      expect(TestSubscriber.allow_low_priority_methods?).to eq(false)
+    end
+
+    it "when the configuration is true it is true" do
+      ::ActionSubscriber.configure { |config| config.allow_low_priority_methods = true }
+      expect(TestSubscriber.allow_low_priority_methods?).to eq(true)
+    end
+  end
+
+  describe "filter_low_priority_methods" do
+    context "when allow_low_priority_methods? is false" do
+      before { allow(TestSubscriber).to receive(:allow_low_priority_methods?).and_return(false) }
+
+      it "removes low priority methods" do
+        filtered_methods = TestSubscriber.filter_low_priority_methods([:updated, :updated_low])
+        expect(filtered_methods).to eq([:updated])
+      end
+    end
+
+    context "when allow_low_priority_methods? is true" do
+      before { allow(TestSubscriber).to receive(:allow_low_priority_methods?).and_return(true) }
+
+      it "allows low priority methods" do
+        filtered_methods = TestSubscriber.filter_low_priority_methods([:updated, :updated_low])
+        expect(filtered_methods).to eq([:updated, :updated_low])
+      end
+    end
+  end
+
+  describe "generate_queue_name" do
+    it "returns a queue name" do
+      queue_name = TestSubscriber.generate_queue_name(:created)
+      expect(queue_name).to eq("alice.bob.test.created")
+    end
+  end
+
+  describe "generate_routing_key_name" do
+    it "returns a routing key name" do
+      routing_key_name = TestSubscriber.generate_routing_key_name(:created)
+      expect(routing_key_name).to eq("bob.test.created")
+    end
+  end
+
+  describe "local_application_name" do
+    it "returns the local application name" do
+      expect(TestSubscriber.local_application_name).to eq("alice")
+    end
+  end
+
+  describe "queue_name_for_method" do
+    before { TestSubscriber.instance_variable_set(:@_queue_names, nil) }
+
+    context "when the queue is already registered" do
+      it "returns the registered queue" do
+        TestSubscriber.queue_for(:created, "foo.bar")
+        queue_name = TestSubscriber.queue_name_for_method(:created)
+        expect(queue_name).to eq("foo.bar")
+      end
+    end
+
+    context "when the queue is not registered" do
+      it "generates a queue name" do
+        queue_name = TestSubscriber.queue_name_for_method(:created)
+        expect(queue_name).to eq("alice.bob.test.created")
+      end
+
+      it "registers the generated queue" do
+        queue_name = TestSubscriber.queue_name_for_method(:created)
+        expect(TestSubscriber.queue_names).to eq({:created =>"alice.bob.test.created"})
+      end
+    end
+  end
+
+  describe "resource_name" do
+    it "returns the resource name" do
+      expect(TestSubscriber.resource_name).to eq("test")
+    end
+  end
+
+  describe "routing_key_name_for_method" do
+    before { TestSubscriber.instance_variable_set(:@_routing_key_names, nil) }
+
+    context "when the routing key is already registered" do
+      it "returns the registered routing key" do
+        TestSubscriber.routing_key_for(:created, "bar.foo")
+        routing_key_name = TestSubscriber.routing_key_name_for_method(:created)
+        expect(routing_key_name).to eq("bar.foo")
+      end
+    end
+
+    context "when the routing key is not registered" do
+      it "generates a routing key name" do
+        routing_key_name = TestSubscriber.routing_key_name_for_method(:created)
+        expect(routing_key_name).to eq("bob.test.created")
+      end
+
+      it "registers the generated routing key" do
+        routing_key_name = TestSubscriber.routing_key_name_for_method(:created)
+        expect(TestSubscriber.routing_key_names).to eq({:created => "bob.test.created"})
+      end
+    end
+  end
+
+  describe "subscribable methods" do
+    it "returns the subscribable methods" do
+      expect(TestSubscriber.subscribable_methods).to eq([:updated])
+    end
+  end
+end