torquebox-console 0.2.3 → 0.2.4

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/lib/stomp/sslparams.rb

@@ -0,0 +1,84 @@
+# -*- encoding: utf-8 -*-
+
+module Stomp
+ #
+ # == Purpose
+ #
+ # Parameters for STOMP ssl connections.
+ #
+ class SSLParams
+
+  # The trust store files. Normally the certificate of the CA that signed
+  # the server's certificate. One file name, or a CSV list of file names.
+  attr_accessor :ts_files
+
+  # The client certificate file.
+  attr_accessor :cert_file
+
+  # The client private key file.
+  attr_accessor :key_file
+
+  # The client private key password.
+  attr_accessor :key_password
+
+  # SSL Connect Verify Result.  The result of the handshake.
+  attr_accessor :verify_result
+
+  # The certificate of the connection peer (the server), received during
+  # the handshake.
+  attr_accessor :peer_cert
+
+  # Optional list of SSL ciphers to be used.  In the format documented for
+  # Ruby's OpenSSL.
+  attr_accessor :ciphers
+
+  # Absolute command to use Ruby default ciphers.
+  attr_reader :use_ruby_ciphers
+
+  # Back reference to the OpenSSL::SSL::SSLContext instance, gem sets before connect.
+  attr_accessor :ctx # Set by the gem during connect, before the callbacks
+
+  # Client wants file existance check on initialize. true/value or false/nil.
+  attr_reader :fsck #
+
+  # initialize returns a valid instance of SSLParams or raises an error.
+  def initialize(opts={})
+
+   # Server authentication parameters
+   @ts_files = opts[:ts_files]   # A trust store file, normally a CA's cert
+   # or a CSV list of cert file names
+
+   # Client authentication parameters
+   @cert_file = opts[:cert_file]         # Client cert
+   @key_file = opts[:key_file]           # Client key
+   @key_password = opts[:key_password]           # Client key password
+   #
+   raise Stomp::Error::SSLClientParamsError if @cert_file.nil? && !@key_file.nil?
+   raise Stomp::Error::SSLClientParamsError if !@cert_file.nil? && @key_file.nil?
+   #
+   @ciphers = opts[:ciphers]
+   @use_ruby_ciphers = opts[:use_ruby_ciphers] ? opts[:use_ruby_ciphers] : false
+   #
+   if opts[:fsck]
+    if @cert_file
+     raise Stomp::Error::SSLNoCertFileError if !File::exists?(@cert_file)
+     raise Stomp::Error::SSLUnreadableCertFileError if !File::readable?(@cert_file)
+    end
+    if @key_file
+     raise Stomp::Error::SSLNoKeyFileError if !File::exists?(@key_file)
+     raise Stomp::Error::SSLUnreadableKeyFileError if !File::readable?(@key_file)
+    end
+    if @ts_files
+     tsa = @ts_files.split(",")
+     tsa.each do |fn|
+      raise Stomp::Error::SSLNoTruststoreFileError if !File::exists?(fn)
+      raise Stomp::Error::SSLUnreadableTruststoreFileError if !File::readable?(fn)
+     end
+    end
+   end
+  end
+
+ end # of class SSLParams
+
+end # of module Stomp
+

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/lib/stomp/version.rb

@@ -0,0 +1,12 @@
+# -*- encoding: utf-8 -*-
+
+module Stomp
+
+  # Define the gem version.
+  module Version  #:nodoc: all
+    MAJOR = 1
+    MINOR = 2
+    PATCH = 8
+    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+  end
+end

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/spec/client_shared_examples.rb

@@ -0,0 +1,71 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+
+shared_examples_for "standard Client" do
+
+  before(:each) do
+    @destination = "/queue/test/ruby/client"
+    @message_text = "test_client-#{Time.now.to_i}"
+  end
+
+  describe "the closed? method" do
+    it "should be false when the connection is open" do
+      @mock_connection.stub!(:closed?).and_return(false)
+      @client.closed?.should == false
+    end
+
+    it "should be true when the connection is closed" do
+      @mock_connection.stub!(:closed?).and_return(true)
+      @client.closed?.should == true
+    end
+  end
+
+  describe "the open? method" do
+    it "should be true when the connection is open" do
+      @mock_connection.stub!(:open?).and_return(true)
+      @client.open?.should == true
+    end
+
+    it "should be false when the connection is closed" do
+      @mock_connection.stub!(:open?).and_return(false)
+      @client.open?.should == false
+    end
+  end
+
+  describe "the subscribe method" do
+
+    before(:each) do
+      @mock_connection.stub!(:subscribe).and_return(true)
+    end
+
+    it "should raise RuntimeError if not passed a block" do
+      lambda {
+        @client.subscribe(@destination)
+      }.should raise_error
+    end
+
+    it "should not raise an error when passed a block" do
+      lambda {
+        @client.subscribe(@destination) {|msg| received = msg}
+      }.should_not raise_error
+    end
+
+    it "should raise RuntimeError on duplicate subscriptions" do
+      lambda {
+        @client.subscribe(@destination)
+        @client.subscribe(@destination)
+      }.should raise_error
+    end
+
+    it "should raise RuntimeError with duplicate id headers" do
+      lambda {
+        @client.subscribe(@destination, {'id' => 'abcdef'})
+        @client.subscribe(@destination, {'id' => 'abcdef'})
+      }.should raise_error
+    end
+
+  end
+
+end
+

data/vendor/bundle/ruby/1.8/gems/stomp-1.2.8/spec/client_spec.rb

@@ -0,0 +1,329 @@
+# -*- encoding: utf-8 -*-
+
+require 'spec_helper'
+require 'client_shared_examples'
+
+
+describe Stomp::Client do
+
+  before(:each) do
+    @mock_connection = mock('connection', :autoflush= => true)
+    Stomp::Connection.stub!(:new).and_return(@mock_connection)
+  end
+
+  describe "(created with no params)" do
+
+    before(:each) do
+      @client = Stomp::Client.new
+    end
+
+    it "should not return any errors" do
+      lambda {
+        @client = Stomp::Client.new
+      }.should_not raise_error
+    end
+
+    it "should not return any errors when created with the open constructor" do
+      lambda {
+        @client = Stomp::Client.open
+      }.should_not raise_error
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(autoflush)" do
+    it "should delegate to the connection for accessing the autoflush property" do
+      @mock_connection.should_receive(:autoflush)
+      Stomp::Client.new.autoflush
+    end
+
+    it "should delegate to the connection for setting the autoflush property" do
+      @mock_connection.should_receive(:autoflush=).with(true)
+      Stomp::Client.new.autoflush = true
+    end
+
+    it "should set the autoflush property on the connection when passing in autoflush as a parameter to the Stomp::Client" do
+      @mock_connection.should_receive(:autoflush=).with(true)
+      Stomp::Client.new("login", "password", 'localhost', 61613, false, true)
+    end
+  end
+
+  describe "(created with invalid params)" do
+
+    it "should return ArgumentError if host is nil" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', nil)
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if host is empty" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', '')
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if port is nil" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', nil)
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if port is < 1" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', 0)
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if port is > 65535" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', 65536)
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if port is empty" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', '')
+      }.should raise_error
+    end
+
+    it "should return ArgumentError if reliable is something other than true or false" do
+      lambda {
+        @client = Stomp::Client.new('login', 'passcode', 'localhost', '12345', 'foo')
+      }.should raise_error
+    end
+
+  end
+
+
+  describe "(created with positional params)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('testlogin', 'testpassword', 'localhost', '12345', false)
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('testlogin')
+      @client.passcode.should eql('testpassword')
+      @client.host.should eql('localhost')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with non-authenticating stomp:// URL and non-TLD host)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://foobar:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('')
+      @client.passcode.should eql('')
+      @client.host.should eql('foobar')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with non-authenticating stomp:// URL and a host with a '-')" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://foo-bar:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('')
+      @client.passcode.should eql('')
+      @client.host.should eql('foo-bar')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+  
+  describe "(created with authenticating stomp:// URL and non-TLD host)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://test-login:testpasscode@foobar:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('test-login')
+      @client.passcode.should eql('testpasscode')
+      @client.host.should eql('foobar')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with authenticating stomp:// URL and a host with a '-')" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://test-login:testpasscode@foo-bar:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('test-login')
+      @client.passcode.should eql('testpasscode')
+      @client.host.should eql('foo-bar')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with non-authenticating stomp:// URL and TLD host)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://host.foobar.com:12345')
+    end
+
+    after(:each) do
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('')
+      @client.passcode.should eql('')
+      @client.host.should eql('host.foobar.com')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+
+  describe "(created with authenticating stomp:// URL and non-TLD host)" do
+
+    before(:each) do
+      @client = Stomp::Client.new('stomp://testlogin:testpasscode@host.foobar.com:12345')
+    end
+
+    it "should properly parse the URL provided" do
+      @client.login.should eql('testlogin')
+      @client.passcode.should eql('testpasscode')
+      @client.host.should eql('host.foobar.com')
+      @client.port.should eql(12345)
+      @client.reliable.should be_false
+    end
+
+    it_should_behave_like "standard Client"
+
+  end
+  
+  describe "(created with failover URL)" do
+    before(:each) do
+      #default options
+      @parameters = {
+        :initial_reconnect_delay => 0.01,
+        :max_reconnect_delay => 30.0,
+        :use_exponential_back_off => true,
+        :back_off_multiplier => 2,
+        :max_reconnect_attempts => 0,
+        :randomize => false,
+        :connect_timeout => 0
+      }
+    end
+    it "should properly parse a URL with failover://" do
+      url = "failover://(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost:61617)"
+
+      @parameters[:hosts] = [
+        {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+    it "should properly parse a URL with failover:" do
+      url = "failover:(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost1:61617),stomp://login3:passcode3@remotehost2:61618)"
+      
+      @parameters[:hosts] = [
+        {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "login2", :passcode => "passcode2", :host => "remotehost1", :port => 61617, :ssl => false},
+        {:login => "login3", :passcode => "passcode3", :host => "remotehost2", :port => 61618, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+    it "should properly parse a URL without user and password" do
+      url = "failover:(stomp://localhost:61616,stomp://remotehost:61617)"
+
+      @parameters[:hosts] = [
+        {:login => "", :passcode => "", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "", :passcode => "", :host => "remotehost", :port => 61617, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+    it "should properly parse a URL with user and/or password blank" do
+      url = "failover:(stomp://:@localhost:61616,stomp://:@remotehost:61617)"
+      
+      @parameters[:hosts] = [
+        {:login => "", :passcode => "", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "", :passcode => "", :host => "remotehost", :port => 61617, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+    it "should properly parse a URL with the options query" do
+      query = "initialReconnectDelay=5000&maxReconnectDelay=60000&useExponentialBackOff=false&backOffMultiplier=3"
+      query += "&maxReconnectAttempts=4&randomize=true&backup=true&timeout=10000"
+      
+      url = "failover:(stomp://login1:passcode1@localhost:61616,stomp://login2:passcode2@remotehost:61617)?#{query}"
+      
+      #backup and timeout are not implemented yet
+      @parameters = {  
+        :initial_reconnect_delay => 5.0,
+        :max_reconnect_delay => 60.0,
+        :use_exponential_back_off => false,
+        :back_off_multiplier => 3,
+        :max_reconnect_attempts => 4,
+        :randomize => true,
+        :connect_timeout => 0
+      }
+      
+      @parameters[:hosts] = [
+        {:login => "login1", :passcode => "passcode1", :host => "localhost", :port => 61616, :ssl => false},
+        {:login => "login2", :passcode => "passcode2", :host => "remotehost", :port => 61617, :ssl => false}
+      ]
+      
+      Stomp::Connection.should_receive(:new).with(@parameters)
+      
+      client = Stomp::Client.new(url)
+      client.parameters.should == @parameters
+    end
+    
+  end
+
+end