sidekick-client 0.1.0

data/lib/ext/bunny-0.6.0/spec/spec_08/bunny_spec.rb

@@ -0,0 +1,65 @@
+# bunny_spec.rb
+
+# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
+# and that it is running on 'localhost'.
+
+# If this is not the case, please change the 'Bunny.new' call below to include
+# the relevant arguments e.g. @b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
+
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. lib bunny]))
+
+describe Bunny do
+
+	before(:each) do
+    @b = Bunny.new
+		@b.start
+	end
+
+  it "should connect to an AMQP server" do
+    @b.status.should == :connected
+  end
+
+	it "should be able to create and open a new channel" do
+		c = @b.create_channel
+		c.number.should == 2
+		c.should be_an_instance_of(Bunny::Channel)
+		@b.channels.size.should == 3
+		c.open.should == :open_ok
+		@b.channel.number.should == 2 
+	end
+	
+	it "should be able to switch between channels" do
+		@b.channel.number.should == 1
+		@b.switch_channel(0)
+		@b.channel.number.should == 0
+	end
+	
+	it "should raise an error if trying to switch to a non-existent channel" do
+		lambda { @b.switch_channel(5)}.should raise_error(RuntimeError)
+	end
+
+	it "should be able to create an exchange" do
+		exch = @b.exchange('test_exchange')
+		exch.should be_an_instance_of(Bunny::Exchange)
+		exch.name.should == 'test_exchange'
+		@b.exchanges.has_key?('test_exchange').should be(true)
+	end
+
+	it "should be able to create a queue" do
+		q = @b.queue('test1')
+		q.should be_an_instance_of(Bunny::Queue)
+		q.name.should == 'test1'
+		@b.queues.has_key?('test1').should be(true)
+  end
+
+	# Current RabbitMQ has not implemented some functionality
+	it "should raise an error if setting of QoS fails" do
+		lambda { @b.qos(:global => true) }.should raise_error(Bunny::ForcedConnectionCloseError)
+		@b.status.should == :not_connected
+	end
+
+	it "should be able to set QoS" do
+		@b.qos.should == :qos_ok
+	end
+	
+end

data/lib/ext/bunny-0.6.0/spec/spec_08/connection_spec.rb

@@ -0,0 +1,12 @@
+# connection_spec.rb
+
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. lib bunny]))
+
+describe Bunny do
+	
+	it "should raise an error if the wrong user name or password is used" do
+		b = Bunny.new(:user => 'wrong')
+		lambda { b.start}.should raise_error(Bunny::ProtocolError)	
+	end
+	
+end

data/lib/ext/bunny-0.6.0/spec/spec_08/exchange_spec.rb

@@ -0,0 +1,162 @@
+# exchange_spec.rb
+
+# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
+# and that it is running on 'localhost'.
+
+# If this is not the case, please change the 'Bunny.new' call below to include
+# the relevant arguments e.g. @b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
+
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. lib bunny]))
+
+describe 'Exchange' do
+
+	before(:each) do
+    @b = Bunny.new
+		@b.start
+	end
+
+	it "should raise an error if instantiated as non-existent type" do
+		lambda { @b.exchange('bogus_ex', :type => :bogus) }.should raise_error(Bunny::ForcedConnectionCloseError)
+		@b.status.should == :not_connected
+	end
+	
+	it "should allow a default direct exchange to be instantiated by specifying :type" do
+		exch = @b.exchange('amq.direct', :type => :direct)
+		exch.should be_an_instance_of(Bunny::Exchange)
+		exch.name.should == 'amq.direct'
+		exch.type.should == :direct
+		@b.exchanges.has_key?('amq.direct').should be(true)
+	end
+	
+	it "should allow a default direct exchange to be instantiated without specifying :type" do
+		exch = @b.exchange('amq.direct')
+		exch.should be_an_instance_of(Bunny::Exchange)
+		exch.name.should == 'amq.direct'
+		exch.type.should == :direct
+		@b.exchanges.has_key?('amq.direct').should be(true)
+	end
+	
+	it "should allow a default fanout exchange to be instantiated without specifying :type" do
+		exch = @b.exchange('amq.fanout')
+		exch.should be_an_instance_of(Bunny::Exchange)
+		exch.name.should == 'amq.fanout'
+		exch.type.should == :fanout
+		@b.exchanges.has_key?('amq.fanout').should be(true)
+	end
+	
+	it "should allow a default topic exchange to be instantiated without specifying :type" do
+		exch = @b.exchange('amq.topic')
+		exch.should be_an_instance_of(Bunny::Exchange)
+		exch.name.should == 'amq.topic'
+		exch.type.should == :topic
+		@b.exchanges.has_key?('amq.topic').should be(true)
+	end
+
+	it "should allow a default headers (amq.match) exchange to be instantiated without specifying :type" do
+		exch = @b.exchange('amq.match')
+		exch.should be_an_instance_of(Bunny::Exchange)
+		exch.name.should == 'amq.match'
+		exch.type.should == :headers
+		@b.exchanges.has_key?('amq.match').should be(true)
+	end
+	
+	it "should allow a default headers (amq.headers) exchange to be instantiated without specifying :type" do
+		exch = @b.exchange('amq.headers')
+		exch.should be_an_instance_of(Bunny::Exchange)
+		exch.name.should == 'amq.headers'
+		exch.type.should == :headers
+		@b.exchanges.has_key?('amq.headers').should be(true)
+	end
+	
+	it "should create an exchange as direct by default" do
+		exch = @b.exchange('direct_defaultex')
+		exch.should be_an_instance_of(Bunny::Exchange)
+		exch.name.should == 'direct_defaultex'
+		exch.type.should == :direct
+		@b.exchanges.has_key?('direct_defaultex').should be(true)
+	end
+	
+	it "should be able to be instantiated as a direct exchange" do
+		exch = @b.exchange('direct_exchange', :type => :direct)
+		exch.should be_an_instance_of(Bunny::Exchange)
+		exch.name.should == 'direct_exchange'
+		exch.type.should == :direct
+		@b.exchanges.has_key?('direct_exchange').should be(true)
+	end
+	
+	it "should be able to be instantiated as a topic exchange" do
+		exch = @b.exchange('topic_exchange', :type => :topic)
+		exch.should be_an_instance_of(Bunny::Exchange)
+		exch.name.should == 'topic_exchange'
+		exch.type.should == :topic
+		@b.exchanges.has_key?('topic_exchange').should be(true)
+	end
+	
+	it "should be able to be instantiated as a fanout exchange" do
+		exch = @b.exchange('fanout_exchange', :type => :fanout)
+		exch.should be_an_instance_of(Bunny::Exchange)
+		exch.name.should == 'fanout_exchange'
+		exch.type.should == :fanout
+		@b.exchanges.has_key?('fanout_exchange').should be(true)
+	end
+
+	it "should be able to be instantiated as a headers exchange" do
+		exch = @b.exchange('headers_exchange', :type => :headers)
+		exch.should be_an_instance_of(Bunny::Exchange)
+		exch.name.should == 'headers_exchange'
+		exch.type.should == :headers
+		@b.exchanges.has_key?('headers_exchange').should be(true)
+	end
+	
+	it "should ignore the :nowait option when instantiated" do
+		exch = @b.exchange('direct2_exchange', :nowait => true)
+	end
+	
+	it "should be able to publish a message" do
+		exch = @b.exchange('direct_exchange')
+		exch.publish('This is a published message')
+	end
+
+  it "should not modify the passed options hash when publishing a message" do
+		exch = @b.exchange('direct_exchange')
+    opts = {:key => 'a', :persistent => true}
+		exch.publish('', opts)
+    opts.should == {:key => 'a', :persistent => true}
+  end
+	
+	it "should be able to return an undeliverable message" do
+		exch = @b.exchange('return_exch')
+		exch.publish('This message should be undeliverable', :immediate => true)
+		ret_msg = @b.returned_message
+		ret_msg.should be_an_instance_of(Hash)
+		ret_msg[:payload].should == 'This message should be undeliverable'
+	end
+	
+	it "should be able to return a message that exceeds maximum frame size" do
+		exch = @b.exchange('return_exch')
+		lg_msg = 'z' * 142000
+		exch.publish(lg_msg, :immediate => true)
+		ret_msg = @b.returned_message
+		ret_msg.should be_an_instance_of(Hash)
+		ret_msg[:payload].should == lg_msg
+	end
+	
+	it "should report an error if delete fails" do
+		exch = @b.exchange('direct_exchange')
+		lambda { exch.delete(:exchange => 'bogus_ex') }.should raise_error(Bunny::ForcedChannelCloseError)
+		@b.channel.active.should == false
+	end
+	
+	it "should be able to be deleted" do
+		exch = @b.exchange('direct_exchange')
+		res = exch.delete
+		res.should == :delete_ok
+		@b.exchanges.has_key?('direct_exchange').should be(false)
+	end
+	
+	it "should ignore the :nowait option when deleted" do
+		exch = @b.exchange('direct2_exchange')
+		exch.delete(:nowait => true)
+	end
+	
+end

data/lib/ext/bunny-0.6.0/spec/spec_08/queue_spec.rb

@@ -0,0 +1,206 @@
+# queue_spec.rb
+
+# Assumes that target message broker/server has a user called 'guest' with a password 'guest'
+# and that it is running on 'localhost'.
+
+# If this is not the case, please change the 'Bunny.new' call below to include
+# the relevant arguments e.g. @b = Bunny.new(:user => 'john', :pass => 'doe', :host => 'foobar')
+
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. lib bunny]))
+
+describe 'Queue' do
+	
+	before(:each) do
+    @b = Bunny.new
+		@b.start
+	end
+	
+	it "should ignore the :nowait option when instantiated" do
+		q = @b.queue('test0', :nowait => true)
+	end
+	
+	it "should ignore the :nowait option when binding to an exchange" do
+		exch = @b.exchange('direct_exch')
+		q = @b.queue('test0')
+		q.bind(exch, :nowait => true).should == :bind_ok
+	end
+	
+	it "should raise an error when trying to bind to a non-existent exchange" do
+		q = @b.queue('test1')
+		lambda {q.bind('bogus')}.should raise_error(Bunny::ForcedChannelCloseError)
+		@b.channel.active.should == false
+	end
+	
+	it "should be able to bind to an existing exchange" do
+		exch = @b.exchange('direct_exch')
+		q = @b.queue('test1')
+		q.bind(exch).should == :bind_ok
+	end
+	
+	it "should ignore the :nowait option when unbinding from an exchange" do
+		exch = @b.exchange('direct_exch')
+		q = @b.queue('test0')
+		q.unbind(exch, :nowait => true).should == :unbind_ok
+	end
+	
+	it "should raise an error if unbinding from a non-existent exchange" do
+		q = @b.queue('test1')
+		lambda {q.unbind('bogus')}.should raise_error(Bunny::ForcedChannelCloseError)
+		@b.channel.active.should == false
+	end
+	
+	it "should be able to unbind from an existing exchange" do
+		exch = @b.exchange('direct_exch')
+		q = @b.queue('test1')
+		q.unbind(exch).should == :unbind_ok
+	end
+
+	it "should be able to publish a message" do
+		q = @b.queue('test1')
+		q.publish('This is a test message')
+		q.message_count.should == 1
+	end
+	
+	it "should be able to pop a message complete with header and delivery details" do
+		q = @b.queue('test1')
+		msg = q.pop()
+		msg.should be_an_instance_of(Hash)
+		msg[:header].should be_an_instance_of(Bunny::Protocol::Header)
+		msg[:payload].should == 'This is a test message'
+		msg[:delivery_details].should be_an_instance_of(Hash)
+		q.message_count.should == 0
+	end
+
+	it "should be able to pop a message and just get the payload" do
+		q = @b.queue('test1')
+		q.publish('This is another test message')
+		msg = q.pop[:payload]
+		msg.should == 'This is another test message'
+		q.message_count.should == 0
+	end
+	
+	it "should be able to pop a message where body length exceeds max frame size" do
+		q = @b.queue('test1')
+		lg_msg = 'z' * 142000
+		q.publish(lg_msg)
+		msg = q.pop[:payload]
+		msg.should == lg_msg
+	end
+	
+	it "should be able call a block when popping a message" do
+		q = @b.queue('test1')
+		q.publish('This is another test message')
+		q.pop { |msg| msg[:payload].should == 'This is another test message' }
+		q.pop { |msg| msg[:payload].should == :queue_empty }
+	end
+	
+	it "should raise an error if purge fails" do
+		q = @b.queue('test1')
+		5.times {q.publish('This is another test message')}
+		q.message_count.should == 5
+		lambda {q.purge(:queue => 'bogus')}.should raise_error(Bunny::ForcedChannelCloseError)
+	end
+	
+	it "should be able to be purged to remove all of its messages" do
+		q = @b.queue('test1')
+		q.message_count.should == 5
+		q.purge.should == :purge_ok
+		q.message_count.should == 0
+	end
+	
+	it "should return an empty message when popping an empty queue" do
+		q = @b.queue('test1')
+		q.publish('This is another test message')
+		q.pop
+		msg = q.pop[:payload]
+		msg.should == :queue_empty
+	end
+	
+	it "should stop subscription without processing messages if max specified is 0" do
+		q = @b.queue('test1')
+		5.times {q.publish('Yet another test message')}
+		q.message_count.should == 5
+		q.subscribe(:message_max => 0)
+		q.message_count.should == 5
+		q.purge.should == :purge_ok
+	end
+	
+	it "should stop subscription after processing number of messages specified > 0" do
+		q = @b.queue('test1')
+		5.times {q.publish('Yet another test message')}
+		q.message_count.should == 5
+		q.subscribe(:message_max => 5)
+	end
+
+	it "should stop subscription after processing message_max messages < total in queue" do
+		q = @b.queue('test1')
+		@b.qos()
+		10.times {q.publish('Yet another test message')}
+		q.message_count.should == 10
+		q.subscribe(:message_max => 5, :ack => true)
+		q.message_count.should == 5
+		q.purge.should == :purge_ok
+	end
+
+	it "should raise an error when delete fails" do
+		q = @b.queue('test1')
+		lambda {q.delete(:queue => 'bogus')}.should raise_error(Bunny::ForcedChannelCloseError)
+		@b.channel.active.should == false
+	end
+
+  it "should pass correct block parameters through on subscribe" do
+    q = @b.queue('test1')
+    q.publish("messages pop\'n")
+
+    q.subscribe do |msg|
+      msg[:header].should be_an_instance_of Qrack::Protocol::Header
+      msg[:payload].should == "messages pop'n"
+      msg[:delivery_details].should_not be_nil
+
+      q.unsubscribe
+			break
+    end
+
+  end
+
+  it "should finish processing subscription messages if break is called in block" do
+    q = @b.queue('test1')
+    q.publish('messages in my quezen')
+
+    q.subscribe do |msg|
+      msg[:payload].should == 'messages in my quezen'
+      q.unsubscribe
+			break
+    end
+
+    5.times {|i| q.publish("#{i}")}
+		q.subscribe do |msg|
+		  if msg[:payload] == '4'
+				q.unsubscribe 
+				break
+			end
+		end
+
+  end
+
+	it "should be able to be deleted" do
+		q = @b.queue('test1')
+		res = q.delete
+		res.should == :delete_ok
+		@b.queues.has_key?('test1').should be(false)
+	end
+	
+	it "should ignore the :nowait option when deleted" do
+		q = @b.queue('test0')
+		q.delete(:nowait => true)
+	end
+
+  it "should support server named queues" do
+    q = @b.queue
+    q.name.should_not == nil
+
+    @b.queue(q.name).should == q
+    q.delete
+  end
+	
+end