bmabey-rosetta_queue 0.2.0 → 0.3.3

data/lib/rosetta_queue/filters.rb

@@ -7,36 +7,36 @@
 
 module RosettaQueue
   class Filters
-    
+
     class << self
-            
+
       def define
         yield self
       end
-      
+
       def reset
         @receiving = nil
         @sending = nil
       end
-    
+
       def receiving(&receiving_filter)
         @receiving = receiving_filter
       end
-    
+
       def sending(&sending_filter)
         @sending = sending_filter
       end
-      
+
       def process_sending(message)
         return message unless @sending
         @sending.call(message)
       end
-      
+
       def process_receiving(message)
         return message unless @receiving
         @receiving.call(message)
       end
-      
+
     end
   end
 end

data/lib/rosetta_queue/logger.rb

@@ -6,7 +6,7 @@ module RosettaQueue
   def self.logger=(new_logger)
     @logger = new_logger
   end
-  
+
   def self.logger
     return @logger if @logger
     raise MissingLogger, "No logger has been set for RosettaQueue.  Please define one with RosettaQueue.logger=."
@@ -19,7 +19,7 @@ module RosettaQueue
   class Logger < ::Logger
 
     def format_message(severity, timestamp, progname, msg)
-      "[#{timestamp.to_formatted_s(:db)}] #{severity} #{msg}\n"
+      "[#{timestamp.to_formatted_s(:db)}] #{severity} -- : #{msg}\n"
     end
 
   end

data/lib/rosetta_queue/message_handler.rb

@@ -1,6 +1,6 @@
 module RosettaQueue
   module MessageHandler
-    
+
     module ClassMethods
 
       attr_reader :destination, :options_hash
@@ -17,17 +17,23 @@ module RosettaQueue
         @destination = destination
       end
     end
-    
+
     def self.included(receiver)
       receiver.extend(ClassMethods)
+      attr_accessor :adapter_proxy
 
       def destination
-        self.class.destination  
+        self.class.destination
       end
-      
+
       def options_hash
         self.class.options_hash
       end
+
+      def ack
+        adapter_proxy.ack unless adapter_proxy.nil?
+      end
+
     end
   end
 end

data/lib/rosetta_queue/producer.rb

@@ -1,12 +1,12 @@
 module RosettaQueue
-  
+
   class Producer < Base
     include MessageHandler
 
     def self.publish(destination, message, options = {})
       RosettaQueue::Adapter.instance.send_message(Destinations.lookup(destination), Filters.process_sending(message), options)
 
-      rescue Exception=>e
+      rescue Exception => e
         RosettaQueue.logger.error("Caught exception in Consumer.publish: #{$!}\n" + e.backtrace.join("\n\t"))
     end
 

data/lib/rosetta_queue/spec_helpers/hash.rb

@@ -1,7 +1,7 @@
 class Hash
   # To be used in conjuction with rspec's predicate matcher.
   #
-  # For example, in story/feature or a functional spec you could say:  
+  # For example, in story/feature or a functional spec you could say:
   #
   # expected_message =  {'name' => 'Advertiser'}
   # expected_message.should be_published_to(:advertiser_create)
@@ -13,9 +13,9 @@ class Hash
     rescue Timeout::Error
       raise "#{destination} should have received a message but did not NOTE: make sure there are no other processes which are polling messages"
     end
-    
+
     # calling should == is kinda wierd, I know.. but in order to get a decent error message it is needed
     received_message.should ==  self
   end
-  
+
 end

data/lib/rosetta_queue/spec_helpers/helpers.rb

@@ -4,18 +4,18 @@ module RosettaQueue
   # World {|world| world.extend RosettaQueue::SpecHelpers }
   module SpecHelpers
     require 'open-uri'
-    
-    # *Currently* only works with ActiveMQ being used as gateway. 
+
+    # *Currently* only works with ActiveMQ being used as gateway.
     # This will clear the queues defined in the RosettaQueue::Destinations mapping.
     # TODO: Figure out a better spot for this to allow for other gateways...
     def clear_queues
-      RosettaQueue::Destinations.queue_names.each do |name| 
+      RosettaQueue::Destinations.queue_names.each do |name|
         queue = name.gsub('/queue/','')
         open("http://127.0.0.1:8161/admin/deleteDestination.action?JMSDestination=#{queue}&JMSDestinationType=queue")
       end
     end
-    
-    # Publishes a given hash as json to the specified destination. 
+
+    # Publishes a given hash as json to the specified destination.
     # Example:
     # publish_message(expected_message, :to => :client_status, :options => {...})
     # The :options will be passed to the publisher and are optional.
@@ -23,14 +23,14 @@ module RosettaQueue
       options[:options] ||= {:persistent => false}
       RosettaQueue::Producer.publish(options[:to], message, options[:options])
     end
-    
+
     # Consumes the first message on queue of consumer that is passed in and uses the consumer to handle it.
     # Example:
     # consume_once_with ClientStatusConsumer
     def consume_once_with(consumer)
       consumer.new.on_message(RosettaQueue::Consumer.receive(consumer.destination))
     end
-    
+
     # Consumes the first message on queue and returns it.
     # Example:
     # message = consume_once :foo_queue
@@ -42,6 +42,6 @@ module RosettaQueue
       sleep 1
       Messaging::Consumer.receive(destination, :persistent => false).to_hash_from_json
     end
-    
+
   end
 end

data/lib/rosetta_queue/spec_helpers/publishing_matchers.rb

@@ -1,6 +1,6 @@
 module RosettaQueue
   module Matchers
-    
+
     class PublishAMessageTo
 
       def initialize(expected_queue_name, options=nil)
@@ -10,14 +10,14 @@ module RosettaQueue
         @expected_queue = expected_queue_name.is_a?(Symbol) ? RosettaQueue::Destinations.lookup(expected_queue_name) : expected_queue_name
       end
 
-      def matches?(lambda_to_run)    
+      def matches?(lambda_to_run)
         #given
         RosettaQueue::Adapter.stub!(:instance).and_return(fake_adapter = RosettaQueue::Gateway::FakeAdapter.new)
         #when
         lambda_to_run.call
         #then
-        @actual_queues = fake_adapter.queues      
-        @number_of_messages_published = @actual_queues.select{ |q| q == @expected_queue}.size 
+        @actual_queues = fake_adapter.queues
+        @number_of_messages_published = @actual_queues.select{ |q| q == @expected_queue}.size
         @number_of_messages_published == @how_many_messages_expected
       end
 
@@ -32,7 +32,7 @@ module RosettaQueue
       def description
         "publish #{message_plural} to the '#{@expected_queue_name}' queue"
       end
-      
+
     private
       def message_plural
         @how_many_messages_expected == 1 ? "a message" : "#{@how_many_messages_expected} messages"
@@ -42,16 +42,16 @@ module RosettaQueue
     def publish_a_message_to(expected_queue)
       PublishAMessageTo.new(expected_queue)
     end
-  
+
     alias :publish_message_to :publish_a_message_to
-    
+
     def publish_messages_to(expected_queue, options)
       PublishAMessageTo.new(expected_queue, options)
     end
-  
+
     class PublishMessageMatcher
-    
-    
+
+
       def matches?(lambda_to_run)
         #given
         RosettaQueue::Adapter.stub!(:instance).and_return(fake_adapter = RosettaQueue::Gateway::FakeAdapter.new)
@@ -61,30 +61,30 @@ module RosettaQueue
         message = fake_adapter.messages_sent_to(@expected_queue).first || ''
         @actual_message = message
       end
-    
+
       protected
       def extract_options(options)
-        if (expected_queue_name = options[:to])        
+        if (expected_queue_name = options[:to])
           @expected_queue = expected_queue_name.is_a?(Symbol) ? RosettaQueue::Destinations.lookup(expected_queue_name) : expected_queue_name
         end
       end
     end
-  
+
     class PublishMessageWith < PublishMessageMatcher
-        
+
       def initialize(message_subset, options)
         @message_subset = message_subset
         extract_options(options)
       end
 
-      def matches?(lambda_to_run)    
+      def matches?(lambda_to_run)
         super
         Spec::Mocks::ArgumentConstraints::HashIncludingConstraint.new(@message_subset) == @actual_message
       end
 
       def failure_message
         if @actual_message.blank?
-          "expected #{@message_subset.inspect} to be contained in a message but no message was published"        
+          "expected #{@message_subset.inspect} to be contained in a message but no message was published"
         else
           "expected #{@message_subset.inspect} to be contained in the message: #{@actual_message.inspect}"
         end
@@ -97,29 +97,29 @@ module RosettaQueue
       def description
         "publish a message with #{@message_subset.inspect}"
       end
-        
+
     end
-    
+
     def publish_message_with(message_subset, options={})
       PublishMessageWith.new(message_subset, options)
     end
-  
-  
+
+
     class PublishMessage < PublishMessageMatcher
-        
+
       def initialize(expected_message, options)
         @expected_message = expected_message
         extract_options(options)
       end
 
-      def matches?(lambda_to_run)    
+      def matches?(lambda_to_run)
         super
         @actual_message == @expected_message
       end
 
       def failure_message
         if @actual_message.blank?
-          "expected #{@expected_message.inspect} to be published but no message was"        
+          "expected #{@expected_message.inspect} to be published but no message was"
         else
           "expected #{@expected_message.inspect} to be published but the following was instead: #{@actual_message.inspect}"
         end
@@ -132,13 +132,13 @@ module RosettaQueue
       def description
         "publish the message: #{@expected_message.inspect}"
       end
-        
+
     end
-    
+
     def publish_message(exact_expected_message, options={})
       PublishMessage.new(exact_expected_message, options)
     end
-    
+
   end
 end
 

data/spec/rosetta_queue/adapter_spec.rb

@@ -1,14 +1,14 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 module RosettaQueue
-  
+
   describe Adapter do
 
     before(:each) do
       @stomp_adapter = mock("Gateway::StompAdapter")
       Adapter.reset
     end
-    
+
     describe ".reset" do
       it "should clear all definitions" do
         Adapter.define { |a| a.type = "null"  }
@@ -17,38 +17,38 @@ module RosettaQueue
         running { Adapter.instance }.should raise_error(AdapterException)
       end
     end
-    
+
     describe ".type=" do
-      
+
       it "should raise error when adapter does not exist" do
-        running { 
+        running {
           Adapter.define do |a|
             a.type = "foo"
           end
           }.should raise_error(AdapterException)
       end
-      
+
     end
-    
+
     describe "adapter not type set" do
       it "should raise an error when .instance is called" do
         # given
         Adapter.define { |a|  }
         # then & when
-        running { Adapter.instance }.should raise_error(AdapterException)        
+        running { Adapter.instance }.should raise_error(AdapterException)
       end
     end
 
     describe "adapter type set" do
-    
+
       before(:each) do
         Adapter.define { |a| a.type = "null" }
       end
-    
+
       it "should return adapter instance" do
         Adapter.instance.class.should == RosettaQueue::Gateway::NullAdapter
       end
-          
+
     end
 
     describe "adapter instantiation" do
@@ -61,41 +61,41 @@ module RosettaQueue
           a.port = "9000"
           a.type = "fake"
         end
-      end 
-      
+      end
+
       def do_process
         Adapter.instance
       end
 
       it "should set opts as an empty has unless variable is set" do
-        during_process { 
+        during_process {
           RosettaQueue::Gateway::FakeAdapter.should_receive(:new).with({:user => "foo", :password => "bar", :host => "localhost", :port => "9000", :opts => {}})
         }
-      end 
+      end
 
       describe "when setting options" do
         before(:each) do
           Adapter.define { |a| a.options = {:vhost => "baz"} }
-        end 
-        
+        end
+
         it "should map adapter_settings to a hash" do
-          during_process { 
+          during_process {
             RosettaQueue::Gateway::FakeAdapter.should_receive(:new).with({:user => "foo", :password => "bar", :host => "localhost", :port => "9000", :opts => {:vhost => "baz"}})
           }
-        end 
-      end 
+        end
+      end
 
       describe "setting options incorrectly (options should always be set as a Hash)" do
-        
+
         before(:each) do
           Adapter.define { |a| a.options = "baz" }
-        end 
-        
+        end
+
         it "should raise an adapter exception" do
           running { Adapter.instance }.should raise_error("Adapter options should be a hash")
-        end 
-      end 
-      
-    end 
+        end
+      end
+
+    end
   end
 end