torquebox-messaging 3.2.0-java → 4.0.0.alpha1-java

data/spec/future_responder_spec.rb

@@ -1,81 +0,0 @@
-require 'torquebox/messaging/future_responder'
-
-include TorqueBox::Messaging
-
-describe TorqueBox::Messaging::FutureResponder do
-  def self.it_should_publish(message, priority=nil, &block)
-    it "should publish with #{message.inspect}#{priority ? ' and priority :' + priority.to_s : ''}" do
-      opts = { :correlation_id => 'ham-biscuit', :ttl => 1234, :encoding => :marshal }
-      opts[:priority] = priority if priority
-      queue = mock('queue')
-      responder = FutureResponder.new(queue, 'ham-biscuit', 1234)
-      queue.should_receive( :publish ).with( hash_including(message), hash_including( opts ) )
-      block.call( responder )
-    end
-  end
-    
-  before(:each) do
-    @queue = mock('queue')
-    @queue.stub(:publish)
-    @responder = FutureResponder.new(@queue, 'correlation-id')
-  end
-
-  describe '#started' do
-    it_should_publish({}, :low) do |responder|
-      responder.started
-    end
-  end
-
-  describe '#status=' do
-    it "should set the status" do
-      @responder.status = 'biscuit'
-      @responder.instance_variable_get('@status').should == 'biscuit'
-    end
-
-    it_should_publish({:status => 'biscuit'}, :normal) do |responder|
-      responder.status = 'biscuit'
-    end
-  end
-
-  describe '#result=' do
-    it "should set the result" do
-      @responder.result = 'biscuit'
-      @responder.instance_variable_get('@result').should == 'biscuit'
-    end
-
-    it_should_publish({:result => 'biscuit'}, :high) do |responder|
-      responder.result = 'biscuit'
-    end
-
-    it "should include the last status with the result" do
-      queue = mock('queue')
-      responder = FutureResponder.new(queue, 'ham-biscuit')
-      queue.should_receive( :publish )
-      responder.status = 'crepe'
-      queue.should_receive( :publish ).with( hash_including({:result => 'biscuit', :status => 'crepe'}), anything )
-      responder.result = 'biscuit'
-    end
-  end
-
-  describe '#error=' do
-    it "should set the error" do
-      @responder.error = 'biscuit'
-      @responder.instance_variable_get('@error').should == 'biscuit'
-    end
-
-    it_should_publish({:error => 'biscuit'}, :high) do |responder|
-      responder.error = 'biscuit'
-    end
-
-    it "should include the last status with the error" do
-      queue = mock('queue')
-      responder = FutureResponder.new(queue, 'ham-biscuit')
-      queue.should_receive( :publish )
-      responder.status = 'crepe'
-      queue.should_receive( :publish ).with( hash_including({:error => 'biscuit', :status => 'crepe'}), anything )
-      responder.error = 'biscuit'
-    end
-
-  end
-
-end

data/spec/future_spec.rb

@@ -1,163 +0,0 @@
-require 'torquebox/messaging/future'
-
-include TorqueBox::Messaging
-
-describe TorqueBox::Messaging::Future do
-  
-  before(:each) do
-    @queue = mock( Queue )
-    @response = nil
-    @queue.stub( :receive ).and_return { @response }
-    @future = Future.new( @queue )
-  end
-
-  describe "#started?" do
-    it "should be false if the remote side hasn't started" do
-      @future.should_not be_started
-    end
-
-    it "should be true if the remote side has started" do
-      @response = { }
-      @future.should be_started
-    end
-
-    it "should be true if an error occurs" do
-      @response = { :error => 'foo' }
-      @future.should be_started
-    end
-
-    it "should be true if an processing is complete" do
-      @response = { :result => 'foo' }
-      @future.should be_started
-    end
-  end
-
-  describe "#complete?" do
-    it "should be false if the remote side hasn't started" do
-      @future.should_not be_complete
-    end
-
-    it "should be false if the remote side hasn't completed" do
-      @response = { }
-      @future.should_not be_complete
-    end
-
-    it "should be false if an error occurs" do
-      @response = { :error => 'foo' }
-      @future.should_not be_complete
-    end
-
-    it "should be true if an processing is complete" do
-      @response = { :result => 'foo' }
-      @future.should be_complete
-    end
-  end
-  
-  describe "#error?" do
-    it "should be false if the remote side hasn't started" do
-      @future.should_not be_error
-    end
-
-    it "should be false if the remote side hasn't completed" do
-      @response = { }
-      @future.should_not be_error
-    end
-
-    it "should be true if an error occurs" do
-      @response = { :error => 'foo' }
-      @future.should be_error
-    end
-
-    it "should be false if an processing is complete" do
-      @response = { :result => 'foo' }
-      @future.should_not be_error
-    end
-  end
-
-  describe '#status' do
-    it "should return nil if no status set" do
-      @future.status.should be_nil
-    end
-
-    it "should return the remote status" do
-      @response = { :status => 'biscuit' }
-      @future.status.should == 'biscuit'
-    end
-
-    it "should remember the last status" do
-      @response = { :status => 'biscuit' }
-      @future.status.should == 'biscuit'
-      @response = { }
-      @future.status.should == 'biscuit'
-    end
-  end
-
-  describe "#all_statuses" do
-    it "should be an emtpy array if no status has been received" do
-      @future.all_statuses.should == []
-    end
-
-    it "should be an have all the seen statuses" do
-      @response = { :status => :ham }
-      @future.status
-      @response = { :status => :biscuit }
-      @future.status
-      @future.all_statuses.should == [:ham, :biscuit]
-    end
-  end
-  
-  describe "#status_changed?" do
-    it "should return false if no status has been sent" do
-      @future.should_not be_status_changed
-    end
-
-    it "should be true for the first status" do
-      @response = { :status => :ham }
-      @future.should be_status_changed
-    end
-    
-    it "should return true if the status doesn't match the last" do
-      @response = { :status => :ham }
-      @future.status
-      @future.should_not be_status_changed
-      @response = { :status => :biscuit }
-      @future.should be_status_changed
-    end
-  end
-  
-  describe "#result" do
-
-    it "should raise if it fails to start before timeout" do
-      lambda { @future.result( 1 ) }.should raise_error( TimeoutException )
-    end
-
-    it "should raise if it fails to complete before timeout" do
-      @response = { }
-      lambda { @future.result( 1 ) }.should raise_error( TimeoutException )
-    end
-
-    it "should raise if a remote error occurs" do
-      @response = { :error => ArgumentError.new }
-      lambda { @future.result( 1 ) }.should raise_error( ArgumentError )
-    end
-
-    it "should return the result if complete" do
-      @response = { :result => :success! }
-      @future.result.should == :success!
-    end
-
-  end
-
-  describe "#method_missing" do
-
-    it "should delegate to #result" do
-      @result = mock(:result)
-      @result.should_receive(:blah)
-      @response = { :result => @result }
-      @future.blah
-    end
-    
-  end
-
-
-end

data/spec/message_processor_spec.rb

@@ -1,211 +0,0 @@
-require 'torquebox/messaging/message_processor'
-require 'torquebox/messaging/message'
-require 'torquebox/messaging/marshal_base64_message'
-
-class MyTestMessage
-  include javax.jms::TextMessage
-  attr_accessor :text
-  def initialize 
-    @properties = {}
-  end
-  def set_string_property k, v
-    @properties[k] = v
-  end
-  def get_string_property k
-    @properties[k]
-  end
-end
-
-class MyTestSession
-  include javax.jms::Session
-
-  def create_text_message
-    MyTestMessage.new
-  end
-end
-
-class MyTestProcessor < TorqueBox::Messaging::MessageProcessor
-  attr_accessor :body
-  def on_message(body)
-    self.body = body
-  end
-end
-
-describe TorqueBox::Messaging::MessageProcessor do
-  
-  before :each do
-    @processor = MyTestProcessor.new
-    @jms_session = MyTestSession.new
-  end
-
-  it "should process text messages" do
-    @processor.should_receive(:synchronous?).and_return(false)
-    @message = TorqueBox::Messaging::Message.new(@jms_session, "foo", :marshal_base64)
-    @processor.process! @message
-    @processor.body.should eql("foo")
-  end
-
-  it "should process non-text messages" do
-    @processor.should_receive(:synchronous?).and_return(false)
-    payload = {:foo => "foo", :sym => :sym, "bar" => :bar}
-    @message = TorqueBox::Messaging::Message.new(@jms_session, payload, :marshal_base64)
-    @processor.process! @message
-    @processor.body.should eql(payload)
-  end
-
-  describe "#middleware" do
-    it "should return the default middleware" do
-      @processor.middleware.inspect.should == "[TorqueBox::Messaging::ProcessorMiddleware::WithTransaction]"
-    end
-  end
-
-  context "lookups" do
-    class ServiceNameMock
-      def initialize(name)
-        @name = name
-      end
-
-      def append(name)
-        @name << ".#{name}"
-        self
-      end
-
-      def canonical_name
-        @name
-      end
-    end
-
-    before(:each) do
-      @service_name = ServiceNameMock.new("jboss.deployment.unit.\"test-message_processor_concurrency-knob.yml\"")
-
-      TorqueBox::MSC.stub_chain(:deployment_unit, :service_name).and_return(@service_name)
-    end
-
-    describe ".list" do
-      class ServiceMock
-        def initialize(name)
-          @name = name
-        end
-
-        attr_reader :name
-
-        def value
-          self
-        end
-      end
-
-      it "should return list of avaialble message processors" do
-        TorqueBox::MSC.should_receive(:get_services).
-          with(/^jboss.deployment.unit."test-message_processor_concurrency-knob.yml".torquebox.messaging\.\".*\"$/).
-          and_yield(ServiceMock.new("jboss.deployment.unit.\"test-message_processor_concurrency-knob.yml\".torquebox.messaging"))
-
-        processors = TorqueBox::Messaging::MessageProcessor.list
-
-        processors.should_not == nil
-        processors.size.should == 1
-      end
-
-      it "should return empty list when no message processors are available" do
-        TorqueBox::MSC.should_receive(:get_services).with(/^jboss.deployment.unit."test-message_processor_concurrency-knob.yml".torquebox.messaging\.\".*\"$/)
-
-        processors = TorqueBox::Messaging::MessageProcessor.list
-
-        processors.should_not == nil
-        processors.size.should == 0
-      end
-    end
-
-    describe ".lookup" do
-      it "should return a message processor" do
-        TorqueBox::ServiceRegistry.should_receive(:lookup).with(@service_name).and_return(mock('Group'))
-
-        processor = TorqueBox::Messaging::MessageProcessor.lookup('/queues/sample', 'SimpleProcessor')
-        processor.should_not == nil
-
-        @service_name.canonical_name.should match(/torquebox\.messaging\.\/queues\/sample\.SimpleProcessor$/)
-      end
-
-      it "should return nil when a message processor is not found" do
-        TorqueBox::ServiceRegistry.should_receive(:lookup).with(@service_name)
-
-        processor = TorqueBox::Messaging::MessageProcessor.lookup('/queues/sample', 'SimpleProcessor')
-        processor.should == nil
-
-        @service_name.canonical_name.should match(/torquebox\.messaging\.\/queues\/sample\.SimpleProcessor$/)
-      end
-    end
-  end
-end
-
-describe TorqueBox::Messaging::MessageProcessorProxy do
-  describe ".new" do
-    it "should not raise when creating the object" do
-      lambda {
-        MessageProcessorProxy.new("group")
-      }.should_not raise_error
-    end
-
-    it "should raise when the group is nil" do
-      lambda {
-        MessageProcessorProxy.new(nil)
-      }.should raise_error(Exception, "Cannot create MessageProcessorProxy for non-existing MessageProcessorGroup")
-    end
-  end
-
-  context "management" do
-    before :each do
-      @group = mock('BaseMessageProcessorGroup')
-      @proxy = MessageProcessorProxy.new(@group)
-    end
-
-    it "should return group properties" do
-      @group.should_receive(:concurrency).and_return(3)
-      @group.should_receive(:message_selector).and_return("something is null")
-      @group.should_receive(:message_processor_class).and_return(mock("Class", :name => 'SimpleProcessor'))
-      @group.should_receive(:destination_name).and_return("/queues/simple")
-      @group.should_receive(:name).and_return("/queues/simple.SimpleProcessor")
-      @group.should_receive(:durable).and_return(false)
-
-      @proxy.concurrency.should == 3
-      @proxy.message_selector.should == "something is null"
-      @proxy.class_name.should == "SimpleProcessor"
-      @proxy.destination_name.should == "/queues/simple"
-      @proxy.name.should == "/queues/simple.SimpleProcessor"
-      @proxy.durable?.should == false
-    end
-
-    describe ".concurrency=" do
-      it "should change the concurrency" do
-        @group.should_receive(:concurrency).and_return(1)
-        @group.should_receive(:concurrency).and_return(3)
-        @group.should_receive(:update_concurrency).with(3).and_return(3)
-
-        (@proxy.concurrency = 3).should == 3
-      end
-
-      it "should allow to set the concurrency to 0" do
-        @group.should_receive(:concurrency).and_return(1)
-        @group.should_receive(:concurrency).and_return(0)
-        @group.should_receive(:update_concurrency).with(0).and_return(0)
-
-        (@proxy.concurrency = 0).should == 0
-      end
-
-      it "should do nothing if the concurrency size is the same" do
-        @group.should_receive(:concurrency).and_return(3)
-        @group.should_not_receive(:update_concurrency)
-
-        (@proxy.concurrency = 3).should == 3
-      end
-
-      it "should raise if the value is lower than 0" do
-        @group.should_receive(:name).and_return("/queues/simple.SimpleProcessor")
-        @group.should_not_receive(:update_concurrency)
-
-        lambda {
-          @proxy.concurrency = -2
-        }.should raise_error(Exception, "Setting concurrency for '/queues/simple.SimpleProcessor' to value < 0 is not allowed. You tried '-2'.")
-      end
-    end
-  end
-end