onstomp 1.0.0pre1

data/spec/onstomp/interfaces/connection_events_spec.rb

@@ -0,0 +1,55 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Interfaces
+  describe ConnectionEvents do
+    let(:client) { mock('client') }
+    let(:eventable) {
+      mock('eventable', :client => client).tap do |m|
+        m.extend ConnectionEvents
+      end
+    }
+  
+    describe "connection event methods" do
+      it "should provide a 'on_established' event" do
+        triggered = false
+        eventable.on_established { triggered = true }
+        eventable.trigger_connection_event :established
+        triggered.should be_true
+      end
+      it "should provide a 'on_closed' event" do
+        triggered = false
+        eventable.on_closed { triggered = true }
+        eventable.trigger_connection_event :closed
+        triggered.should be_true
+      end
+      it "should provide a 'on_died' event" do
+        triggered = false
+        eventable.on_died { triggered = true }
+        eventable.trigger_connection_event :died
+        triggered.should be_true
+      end
+      it "should provide a 'on_terminated' event" do
+        triggered = false
+        eventable.on_terminated { triggered = true }
+        eventable.trigger_connection_event :terminated
+        triggered.should be_true
+      end
+    end
+    
+    describe ".install_bindings_from_client" do
+      let(:callback1) { mock('callback1') }
+      let(:callback2) { mock('callback2') }
+      let(:callback3) { mock('callback3') }
+      
+      it "should bind events from the hash and trigger connected" do
+        eventable.should_receive(:bind_event).with(:ev1, callback3)
+        eventable.should_receive(:bind_event).with(:ev1, callback2)
+        eventable.should_receive(:bind_event).with(:ev2, callback1)
+        eventable.should_receive(:trigger_connection_event).with(:established)
+        eventable.install_bindings_from_client :ev1 => [callback3, callback2], 
+          :ev2 => [callback1]
+      end
+    end
+  end
+end

data/spec/onstomp/interfaces/event_manager_spec.rb

@@ -0,0 +1,72 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Interfaces
+  describe EventManager do
+    let(:eventable) {
+      mock('eventable').tap do |m|
+        m.extend EventManager
+      end
+    }
+    describe ".bind_event / .trigger_event" do
+      it "should bind a proc and call it when the event is triggered" do
+        triggered = nil
+        eventable.bind_event(:some_event_name,
+          lambda { |a1, a2| triggered = [a1, a2] })
+        eventable.trigger_event :some_event_name, 3, 'test'
+        triggered.should == [3, 'test']
+      end
+    end
+    
+    describe ".event_callbacks" do
+      it "should provide an empty array for an unbound event" do
+        eventable.event_callbacks[:foo_bar_bazz].should == []
+      end
+    end
+    
+    describe "::create_event_method(s)" do
+      before(:each) do
+        class TestEventManager
+          include EventManager
+          create_event_method  :foo_event1
+          create_event_methods :foo_event2
+          create_event_methods :foo_event3, :before, :during, :after
+        end
+      end
+      let(:test_eventable) {
+        TestEventManager.new
+      }
+      
+      it "should have a 'foo_event' method" do
+        triggered = false
+        test_eventable.foo_event1 { triggered = true }
+        test_eventable.trigger_event :foo_event1, 'arg'
+        triggered.should be_true
+      end
+      it "should have a 'on_foo_event2' method" do
+        triggered = false
+        test_eventable.on_foo_event2 { triggered = true }
+        test_eventable.trigger_event :on_foo_event2, 'arg'
+        triggered.should be_true
+      end
+      it "should have a 'before_foo_event3' method" do
+        triggered = false
+        test_eventable.before_foo_event3 { triggered = true }
+        test_eventable.trigger_event :before_foo_event3, 'arg'
+        triggered.should be_true
+      end
+      it "should have a 'during_foo_event3' method" do
+        triggered = false
+        test_eventable.during_foo_event3 { triggered = true }
+        test_eventable.trigger_event :during_foo_event3, 'arg'
+        triggered.should be_true
+      end
+      it "should have a 'after_foo_event3' method" do
+        triggered = false
+        test_eventable.after_foo_event3 { triggered = true }
+        test_eventable.trigger_event :after_foo_event3, 'arg'
+        triggered.should be_true
+      end
+    end
+  end
+end

data/spec/onstomp/interfaces/frame_methods_spec.rb

@@ -0,0 +1,109 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Interfaces
+  describe FrameMethods do
+    let(:connection) {
+      mock('connection')
+    }
+    let(:framer) {
+      mock('framer', :connection => connection).tap do |m|
+        m.extend FrameMethods
+      end
+    }
+    let(:headers) {
+      { :header1 => 'value 1' }
+    }
+    let(:frame) {
+      mock('frame')
+    }
+    let(:callback) {
+      lambda { }
+    }
+    
+    describe ".send" do
+      it "should transmit the result of connection.send_frame and callbacks" do
+        connection.should_receive(:send_frame).with('/queue/test', 'frame body', headers).and_return(frame)
+        framer.should_receive(:transmit).with(frame, { :receipt => callback })
+        framer.send('/queue/test', 'frame body', headers, &callback)
+      end
+      it "should be aliased as .puts" do
+        connection.should_receive(:send_frame).with('/queue/test', 'frame body', headers).and_return(frame)
+        framer.should_receive(:transmit).with(frame, { :receipt => callback })
+        framer.puts('/queue/test', 'frame body', headers, &callback)
+      end
+    end
+    
+    describe ".subscribe" do
+      it "should transmit the result of connection.subscribe_frame and callbacks" do
+        connection.should_receive(:subscribe_frame).with('/queue/test2', headers).and_return(frame)
+        framer.should_receive(:transmit).with(frame, { :subscribe => callback })
+        framer.subscribe('/queue/test2', headers, &callback)
+      end
+    end
+    
+    describe ".unsubscribe" do
+      it "should transmit the result of connection.unsubscribe_frame" do
+        connection.should_receive(:unsubscribe_frame).with('frame_or_id', headers).and_return(frame)
+        framer.should_receive(:transmit).with(frame)
+        framer.unsubscribe('frame_or_id', headers)
+      end
+    end
+    
+    describe ".begin" do
+      it "should transmit the result of connection.begin_frame" do
+        connection.should_receive(:begin_frame).with('tx_id', headers).and_return(frame)
+        framer.should_receive(:transmit).with(frame)
+        framer.begin('tx_id', headers)
+      end
+    end
+    
+    describe ".abort" do
+      it "should transmit the result of connection.abort_frame" do
+        connection.should_receive(:abort_frame).with('tx_id', headers).and_return(frame)
+        framer.should_receive(:transmit).with(frame)
+        framer.abort('tx_id', headers)
+      end
+    end
+    
+    describe ".commit" do
+      it "should transmit the result of connection.commit_frame" do
+        connection.should_receive(:commit_frame).with('tx_id', headers).and_return(frame)
+        framer.should_receive(:transmit).with(frame)
+        framer.commit('tx_id', headers)
+      end
+    end
+    
+    describe ".disconnect" do
+      it "should transmit the result of connection.disconnect_frame" do
+        connection.should_receive(:disconnect_frame).with(headers).and_return(frame)
+        framer.should_receive(:transmit).with(frame)
+        framer.disconnect(headers)
+      end
+    end
+    
+    describe ".ack" do
+      it "should transmit the result of connection.ack_frame" do
+        connection.should_receive(:ack_frame).with('arg1', headers, :arg2).and_return(frame)
+        framer.should_receive(:transmit).with(frame)
+        framer.ack('arg1', headers, :arg2)
+      end
+    end
+    
+    describe ".nack" do
+      it "should transmit the result of connection.nack_frame" do
+        connection.should_receive(:nack_frame).with('arg1', headers, :arg2).and_return(frame)
+        framer.should_receive(:transmit).with(frame)
+        framer.nack('arg1', headers, :arg2)
+      end
+    end
+    
+    describe ".beat" do
+      it "should transmit the result of connection.heartbeat_frame" do
+        connection.should_receive(:heartbeat_frame).and_return(frame)
+        framer.should_receive(:transmit).with(frame)
+        framer.beat
+      end
+    end
+  end
+end

data/spec/onstomp/interfaces/receipt_manager_spec.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Interfaces
+  describe ReceiptManager do
+    let(:client) {
+      mock('mock client').tap do |m|
+        m.extend ClientEvents
+        m.extend ReceiptManager
+      end
+    }
+    let(:frame) {
+      OnStomp::Components::Frame.new('COMMAND', :receipt => 'r-1234')
+    }
+    let(:receipt_frame) {
+      OnStomp::Components::Frame.new('RECEIPT', :'receipt-id' => 'r-1234')
+    }
+    before(:each) do
+      client.__send__(:configure_receipt_management)
+    end
+    after(:each) do
+      client.__send__(:clear_receipts)
+    end
+        
+    describe "adding receipt callbacks" do
+      it "should add a callback and invoke it upon receiving its RECEIPT" do
+        triggered = false
+        client.__send__ :add_receipt, frame, lambda { |r| triggered = true }
+        client.trigger_after_receiving receipt_frame
+        triggered.should be_true
+      end
+      it "should create a receipt header if one does not exist" do
+        frame.headers.delete :receipt
+        triggered = false
+        client.__send__ :add_receipt, frame, lambda { |r| triggered = true }
+        frame[:receipt].should_not be_nil
+        frame[:receipt].should_not be_empty
+        receipt_frame[:'receipt-id'] = frame[:receipt]
+        client.trigger_after_receiving receipt_frame
+        triggered.should be_true
+      end
+    end
+    
+    describe "receipted DISCONNECT" do
+      it "should close the client upon receiving a RECEIPT for a DISCONNECT" do
+        frame.command = 'DISCONNECT'
+        client.trigger_before_transmitting frame
+        client.should_receive(:close)
+        client.trigger_after_receiving receipt_frame
+      end
+    end
+  end
+end

data/spec/onstomp/interfaces/subscription_manager_spec.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+module OnStomp::Interfaces
+  describe SubscriptionManager do
+    let(:client) {
+      mock('client').tap do |m|
+        m.extend ClientEvents
+        m.extend SubscriptionManager
+      end
+    }
+    let(:message_frame) {
+      OnStomp::Components::Frame.new('MESSAGE', :subscription => 's-1234',
+        :destination => '/queue/test')
+    }
+    let(:subscribe_frame) {
+      OnStomp::Components::Frame.new('SUBSCRIBE', :id => 's-1234',
+        :destination => '/queue/test')
+    }
+    let(:unsubscribe_frame) {
+      OnStomp::Components::Frame.new('UNSUBSCRIBE', :id => 's-1234')
+    }
+    let(:subscribed_frames) { [] }
+    let(:callback) {
+      lambda { |m| subscribed_frames << m }
+    }
+    
+    before(:each) do
+      client.__send__(:configure_subscription_management)
+    end
+    after(:each) do
+      client.__send__(:clear_subscriptions)
+    end
+    
+    describe "adding subscription callbacks" do
+      it "should add a callback and invoke it upon receiving matching MESSAGE" do
+        client.__send__ :add_subscription, subscribe_frame, callback
+        client.subscriptions.map { |s| [s.id, s.callback] }.should ==
+          [ ['s-1234', callback] ]
+        client.trigger_after_receiving message_frame
+        client.trigger_after_receiving message_frame
+        subscribed_frames.should == [message_frame, message_frame]
+      end
+      it "should invoke the callback if there is no subscription header but destinations match" do
+        message_frame.headers.delete :subscription
+        client.__send__ :add_subscription, subscribe_frame, callback
+        client.trigger_after_receiving message_frame
+        client.trigger_after_receiving message_frame
+        subscribed_frames.should == [message_frame, message_frame]
+      end
+    end
+    
+    describe "unsubscribing" do
+      it "should not invoke the callback after UNSUBSCRIBE has been processed" do
+        client.__send__ :add_subscription, subscribe_frame, callback
+        client.trigger_after_receiving message_frame
+        client.trigger_after_receiving unsubscribe_frame
+        client.trigger_after_receiving message_frame
+        subscribed_frames.should == [message_frame]
+        client.subscriptions.should be_empty
+      end
+    end
+  end
+end

data/spec/onstomp_spec.rb

@@ -0,0 +1,15 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+describe OnStomp do
+  describe ".connect / .open" do
+    let(:client) { mock('client') }
+    let(:client_uri) { mock('uri') }
+    let(:client_options) { mock('options') }
+    it "should create a new client and connect it" do
+      OnStomp::Client.should_receive(:new).with(client_uri, client_options).and_return(client)
+      client.should_receive(:connect)
+      OnStomp.open(client_uri, client_options).should == client
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+Dir[File.expand_path('support', File.dirname(__FILE__)) + "/**/*.rb"].each { |f| require f }
+
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+rescue LoadError
+end
+
+require 'onstomp'

data/spec/support/custom_argument_matchers.rb

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      def an_onstomp_frame(command=false, header_arr=false, body=false)
+        OnStompFrameMatcher.new(command, header_arr, body).tap do |m|
+          m.match_command = command != false
+          m.match_headers = header_arr != false
+          m.match_body = body != false
+        end
+      end
+      
+      class OnStompFrameMatcher
+        attr_accessor :match_command, :match_body, :match_headers
+        
+        def initialize(com, header_arr, body)
+          @match_command = @match_body = @match_headers = true
+          @expected = OnStomp::Components::Frame.new(com, {}, body)
+          header_arr = [header_arr] if header_arr.is_a?(Hash)
+          header_arr.each do |h|
+            @expected.headers.merge!(h)
+          end if header_arr.is_a?(Array)
+        end
+        
+        def ==(actual)
+          actual.is_a?(@expected.class) && matches_command(actual) &&
+            matches_headers(actual) && matches_body(actual)
+        end
+        
+        def matches_command actual
+          !match_command || actual.command == @expected.command
+        end
+        
+        def matches_body actual
+          !match_body || actual.body == @expected.body
+        end
+        
+        def matches_headers actual
+          !match_headers || @expected.headers.to_hash.keys.all? { |k| @expected[k] == actual[k] }
+        end
+        
+        def description
+          frame_desc = match_command ? "#{@expected.command} frame" : "Any frame"
+          header_desc = match_headers ? " with headers #{@expected.headers.to_hash.inspect}" : ''
+          body_desc = match_body ? " and body '#{@expected.body}'" : ''
+          [frame_desc, header_desc, body_desc].join
+        end
+      end
+    end
+  end
+end

data/spec/support/frame_matchers.rb

@@ -0,0 +1,88 @@
+# -*- encoding: utf-8 -*-
+RSpec::Matchers.define :have_header_named do |header_name|
+  match do |actual|
+    actual.headers.set? header_name
+  end
+end
+
+RSpec::Matchers.define :have_headers do |expected_hash|
+  match do |actual|
+    expected_hash.inject(true) do |matched, (k,v)|
+      matched && actual[k] == v
+    end
+  end
+end
+
+RSpec::Matchers.define :be_a_header_scope do |headers|
+  match do |actual|
+    actual.is_a?(OnStomp::Components::Scopes::HeaderScope) &&
+      actual.headers == headers
+  end
+end
+
+RSpec::Matchers.define :be_a_receipt_scope do |callback|
+  match do |actual|
+    actual.is_a?(OnStomp::Components::Scopes::ReceiptScope) &&
+      actual.callback == callback
+  end
+end
+
+RSpec::Matchers.define :be_a_transaction_scope do |tx_id|
+  match do |actual|
+    $stdout.puts "Checking transaction? #{tx_id.inspect}"
+    type_check = actual.is_a?(OnStomp::Components::Scopes::TransactionScope)
+    tx_id ? type_check && actual.transaction == tx_id : type_check
+  end
+end
+
+RSpec::Matchers.define :be_an_onstomp_frame do |com, head, body|
+  match do |actual|
+    checked = actual.is_a?(OnStomp::Components::Frame)
+    checked &&= actual.command == com
+    checked &&= head.inject(checked) do |matched, (k,v)|
+      matched && actual[k] == v
+    end
+    checked &&= actual.body == body
+  end
+end
+
+RSpec::Matchers.define :be_an_encoded_onstomp_frame do |com, head, body, enc|
+  match do |actual|
+    if RUBY_VERSION >= '1.9'
+      enc_check = actual.body.encoding.name == enc
+      body.force_encoding(enc)
+    else
+      enc_check = true
+    end
+    enc_check && actual.should(be_an_onstomp_frame(com, head, body))
+  end
+end
+
+RSpec::Matchers.define :have_transaction_header do |expected|
+  have_frame_header :transaction, expected
+end
+
+RSpec::Matchers.define :have_command do |expected|
+  match do |actual|
+    actual.command.should == expected
+  end
+end
+
+RSpec::Matchers.define :have_body_encoding do |expected|
+  if RUBY_VERSION >= "1.9"
+    match do |actual|
+      actual.body.encoding.name.should == expected
+    end
+  else
+    match do |actual|
+      true.should be_true
+    end
+  end
+end
+
+RSpec::Matchers.define :have_body do |expected, expected_no_encoding, encoding|
+  e_expected = (RUBY_VERSION >= '1.9') ? expected.encode(encoding) : expected_no_encoding
+  match do |actual|
+    actual.body.should == e_expected
+  end
+end

data/spec/support/shared_frame_method_examples.rb

@@ -0,0 +1,116 @@
+shared_examples_for "frame method interfaces" do
+  let(:shared_frame_method_headers) {
+    { :header1 => 'value 1' }
+  }
+  let(:shared_frame_methods_transmit_callbacks) {
+    Hash.new
+  }
+  
+  before(:each) do
+    if frame_method_interface.respond_to?(:connection)
+      frame_method_interface.stub(
+        :connection => OnStomp::Connections::Stomp_1_1.new(mock('io'), client)
+      )
+    end
+  end
+  
+  describe ".send" do
+    it "should transmit the result of connection.send_frame and callbacks" do
+      frame_method_interface.should_receive(:transmit).
+        with(an_onstomp_frame('SEND',
+          [shared_frame_method_headers, {:destination => '/queue/test'}],
+          'message body'), an_instance_of(Hash))
+      frame_method_interface.send('/queue/test', 'message body', shared_frame_method_headers)
+    end
+    it "should be aliased as .puts" do
+      frame_method_interface.should_receive(:transmit).
+        with(an_onstomp_frame('SEND',
+          [shared_frame_method_headers, {:destination => '/queue/test'}],
+          'message body'), an_instance_of(Hash))
+      frame_method_interface.puts('/queue/test', 'message body', shared_frame_method_headers)
+    end
+  end
+
+  describe ".subscribe" do
+    it "should transmit the result of connection.subscribe_frame and callbacks" do
+      frame_method_interface.should_receive(:transmit).
+        with(an_onstomp_frame('SUBSCRIBE',
+          [shared_frame_method_headers, {:destination => '/queue/test'}]),
+          an_instance_of(Hash))
+      frame_method_interface.subscribe('/queue/test', shared_frame_method_headers)
+    end
+  end
+
+  describe ".unsubscribe" do
+    it "should transmit the result of connection.unsubscribe_frame" do
+      frame_method_interface.should_receive(:transmit).
+        with(an_onstomp_frame('UNSUBSCRIBE',
+          [shared_frame_method_headers, {:id => 's-1234'}]))
+      frame_method_interface.unsubscribe('s-1234', shared_frame_method_headers)
+    end
+  end
+
+  describe ".begin" do
+    it "should transmit the result of connection.begin_frame" do
+      frame_method_interface.should_receive(:transmit).
+        with(an_onstomp_frame('BEGIN',
+          [shared_frame_method_headers, {:transaction => 't-1234'}]))
+      frame_method_interface.begin('t-1234', shared_frame_method_headers)
+    end
+  end
+
+  describe ".abort" do
+    it "should transmit the result of connection.abort_frame" do
+      frame_method_interface.should_receive(:transmit).
+        with(an_onstomp_frame('ABORT',
+          [shared_frame_method_headers, {:transaction => 't-1234'}]))
+      frame_method_interface.abort('t-1234', shared_frame_method_headers)
+    end
+  end
+
+  describe ".commit" do
+    it "should transmit the result of connection.commit_frame" do
+      frame_method_interface.should_receive(:transmit).
+        with(an_onstomp_frame('COMMIT',
+          [shared_frame_method_headers, {:transaction => 't-1234'}]))
+      frame_method_interface.commit('t-1234', shared_frame_method_headers)
+    end
+  end
+
+  describe ".disconnect" do
+    it "should transmit the result of connection.disconnect_frame" do
+      frame_method_interface.should_receive(:transmit).
+        with(an_onstomp_frame('DISCONNECT',
+          [shared_frame_method_headers]))
+      frame_method_interface.disconnect(shared_frame_method_headers)
+    end
+  end
+
+  describe ".ack" do
+    it "should transmit the result of connection.ack_frame" do
+      frame_method_interface.should_receive(:transmit).
+        with(an_onstomp_frame('ACK',
+          [shared_frame_method_headers, {:'message-id' => 'm-1234',
+            :subscription => 's-5678'}]))
+      frame_method_interface.ack('m-1234', 's-5678', shared_frame_method_headers)
+    end
+  end
+
+  describe ".nack" do
+    it "should transmit the result of connection.nack_frame" do
+      frame_method_interface.should_receive(:transmit).
+        with(an_onstomp_frame('NACK',
+          [shared_frame_method_headers, {:'message-id' => 'm-1234',
+            :subscription => 's-5678'}]))
+      frame_method_interface.nack('m-1234', 's-5678', shared_frame_method_headers)
+    end
+  end
+
+  describe ".beat" do
+    it "should transmit the result of connection.heartbeat_frame" do
+      frame_method_interface.should_receive(:transmit).
+        with(an_onstomp_frame(nil))
+      frame_method_interface.beat
+    end
+  end
+end

data/yard_extensions.rb

@@ -0,0 +1,32 @@
+class ConfigurableAttributeHandler < YARD::Handlers::Ruby::AttributeHandler
+  handles method_call(:attr_configurable_str)
+  handles method_call(:attr_configurable_client_beats)
+  handles method_call(:attr_configurable_protocols)
+  namespace_only
+  
+  def process
+    name = statement.parameters.first.jump(:symbol, :ident).source
+    namespace.attributes[scope][name] ||= SymbolHash[:read => nil, :write => nil]
+    namespace.attributes[scope][name][:read] = YARD::CodeObjects::MethodObject.new(namespace, name)
+    namespace.attributes[scope][name][:write] = YARD::CodeObjects::MethodObject.new(namespace, "#{name}=")
+    register namespace.attributes[scope][name][:read]
+    register namespace.attributes[scope][name][:write]
+  end
+end
+
+class EventMethodsHandler < YARD::Handlers::Ruby::MethodHandler
+  handles method_call(:create_event_methods)
+  namespace_only
+  
+  def process
+    base_name = statement.parameters.first.jump(:symbol, :ident).source[1..-1]
+    statement.parameters[1..-1].each do |pref_sexp|
+      if pref_sexp
+        pref = pref_sexp.jump(:symbol, :ident).source[1..-1]
+        name = "#{pref}_#{base_name}"
+        object = YARD::CodeObjects::MethodObject.new(namespace, name)
+        register object
+      end
+    end
+  end
+end