torquebox-console 0.2.5 → 0.3.0

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

@@ -1,84 +0,0 @@
-# -*- 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

@@ -1,12 +0,0 @@
-# -*- 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

@@ -1,71 +0,0 @@
-# -*- 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

@@ -1,329 +0,0 @@
-# -*- 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