From f83677056891e436bf5ba99e79240df2a44528cd Mon Sep 17 00:00:00 2001 From: "Stephen D. Huston" Date: Fri, 21 Oct 2011 14:42:12 +0000 Subject: Merged out from trunk git-svn-id: https://svn.apache.org/repos/asf/qpid/branches/QPID-2519@1187375 13f79535-47bb-0310-9956-ffa450edef68 --- cpp/bindings/qpid/ruby/test/lib/setup.rb | 29 ++ cpp/bindings/qpid/ruby/test/test_address.rb | 39 +++ cpp/bindings/qpid/ruby/test/test_connection.rb | 257 ++++++++++++++ cpp/bindings/qpid/ruby/test/test_encoding.rb | 146 ++++++++ cpp/bindings/qpid/ruby/test/test_message.rb | 353 ++++++++++++++++++++ cpp/bindings/qpid/ruby/test/test_receiver.rb | 238 +++++++++++++ cpp/bindings/qpid/ruby/test/test_sender.rb | 183 ++++++++++ cpp/bindings/qpid/ruby/test/test_session.rb | 445 +++++++++++++++++++++++++ cpp/bindings/qpid/ruby/test/ts_bindings.rb | 30 ++ 9 files changed, 1720 insertions(+) create mode 100644 cpp/bindings/qpid/ruby/test/lib/setup.rb create mode 100644 cpp/bindings/qpid/ruby/test/test_address.rb create mode 100644 cpp/bindings/qpid/ruby/test/test_connection.rb create mode 100644 cpp/bindings/qpid/ruby/test/test_encoding.rb create mode 100644 cpp/bindings/qpid/ruby/test/test_message.rb create mode 100644 cpp/bindings/qpid/ruby/test/test_receiver.rb create mode 100644 cpp/bindings/qpid/ruby/test/test_sender.rb create mode 100644 cpp/bindings/qpid/ruby/test/test_session.rb create mode 100644 cpp/bindings/qpid/ruby/test/ts_bindings.rb (limited to 'cpp/bindings/qpid/ruby/test') diff --git a/cpp/bindings/qpid/ruby/test/lib/setup.rb b/cpp/bindings/qpid/ruby/test/lib/setup.rb new file mode 100644 index 0000000000..c4901ed907 --- /dev/null +++ b/cpp/bindings/qpid/ruby/test/lib/setup.rb @@ -0,0 +1,29 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +$:.unshift File.join(File.dirname(__FILE__), "..", "lib") + +require 'qpid' + +def create_session url, session_name + conn = Qpid::Messaging::Connection.new url + conn.open + conn.create_session session_name +end + diff --git a/cpp/bindings/qpid/ruby/test/test_address.rb b/cpp/bindings/qpid/ruby/test/test_address.rb new file mode 100644 index 0000000000..f54e93aa3d --- /dev/null +++ b/cpp/bindings/qpid/ruby/test/test_address.rb @@ -0,0 +1,39 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +$:.unshift File.join(File.dirname(__FILE__), "..", "lib") + +require 'test/unit' +require 'flexmock/test_unit' + +require 'cqpid' +require 'qpid/address' + +class TestAddress < Test::Unit::TestCase + + def test_constructor + result = Qpid::Messaging::Address.new "name", "subject", {:foo => :bar}, "type" + + assert_equal "name", result.name + assert_equal "subject", result.subject + assert_equal "type", result._type + end + +end + diff --git a/cpp/bindings/qpid/ruby/test/test_connection.rb b/cpp/bindings/qpid/ruby/test/test_connection.rb new file mode 100644 index 0000000000..648fb0588a --- /dev/null +++ b/cpp/bindings/qpid/ruby/test/test_connection.rb @@ -0,0 +1,257 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +$:.unshift File.join(File.dirname(__FILE__), "..", "lib") + +require 'test/unit' +require 'flexmock/test_unit' + +require 'cqpid' +require 'qpid/connection' + +class TestConnection < Test::Unit::TestCase + + def setup + @connection_impl = flexmock("connection_impl") + @other_connection = flexmock("other_connection") + @other_connection_impl = flexmock("other_connection_impl") + @cqpid_connection = flexmock(Cqpid::Connection) + + @session = flexmock("session") + @session_name = "test-session" + + @url = "localhost" + @options = {} + + @connection = Qpid::Messaging::Connection.new(@url, @options, @connection_impl) + end + + def test_create_with_username_and_password + @cqpid_connection. + should_receive(:new). + once.with("localhost", + {"username" => "username", + "password" => "password"}). + and_return(@connection_impl) + @connection_impl. + should_receive(:open). + once + + result = Qpid::Messaging::Connection.new("localhost", + :username => "username", + :password => "password") + result.open + + assert_same @connection_impl, result.connection_impl + end + + def test_create_with_hostname + result = Qpid::Messaging::Connection.new("localhost") + + assert_not_nil result + end + + def test_open + @cqpid_connection. + should_receive(:new). + once. + with(@url, {}). + and_return(@connection_impl) + @connection_impl. + should_receive(:open). + once + + @connection.open + + assert_same @connection_impl, @connection.connection_impl + end + + def test_check_open_when_open + @connection_impl. + should_receive(:isOpen). + once. + and_return(true) + + assert @connection.open? + end + + def test_check_open_before_connection + result = Qpid::Messaging::Connection.new("hostname") + + assert !result.open? + end + + def test_check_open_when_closed + @connection_impl. + should_receive(:isOpen). + once. + and_return(false) + + assert !@connection.open? + end + + def test_close_an_unopened_session + @connection_impl. + should_receive(:isOpen). + once. + and_return(false) + + @connection.close + end + + def test_close + @connection_impl. + should_receive(:isOpen). + once. + and_return(true). + should_receive(:close). + once + + @connection.close + end + + def test_create_session_without_name + @connection_impl. + should_receive(:isOpen). + once. + and_return(true). + should_receive(:createSession). + once. + with(""). + and_return(@session) + + result = @connection.create_session + + assert_not_nil result + assert_same @session, result.session_impl + end + + def test_create_session + @connection_impl. + should_receive(:isOpen). + once. + and_return(true). + should_receive(:createSession). + once. + with(@session_name). + and_return(@session) + + result = @connection.create_session :name => @session_name + + assert_not_nil result + assert_same @session, result.session_impl + end + + def test_create_session_raises_exception_when_closed + @connection_impl. + should_receive(:isOpen). + once. + and_return(false) + + assert_raise(RuntimeError) {@connection.create_session @session_name} + end + + def test_create_transactional_session + @connection_impl. + should_receive(:isOpen). + once. + and_return(true). + should_receive(:createTransactionalSession). + once. + with(""). + and_return(@session) + + result = @connection.create_session :transactional => true + + assert_not_nil result + assert_same @session, result.session_impl + end + + def test_authenticated_username_when_not_connected + @connection_impl. + should_receive(:isOpen). + once. + and_return(false) + + result = @connection.authenticated_username + + assert_nil result + end + + def test_authenticated_username + @connection_impl. + should_receive(:isOpen). + once. + and_return(true). + should_receive(:getAuthenticatedUsername). + once. + and_return("farkle") + + result = @connection.authenticated_username + + assert_equal "farkle", result + end + + def test_get_session_with_invalid_name + @connection_impl. + should_receive(:getSession). + once. + with(@session_name). + and_return(nil) + + result = @connection.session @session_name + + assert_nil result + end + + # APIs inherited from Handle + + def test_is_valid + @connection_impl. + should_receive(:isValid). + once. + and_return(true) + + assert @connection.valid? + end + + def test_is_null + @connection_impl. + should_receive(:isNull). + once. + and_return(false) + + assert !@connection.null? + end + + def test_swap + @other_connection. + should_receive(:connection_impl). + once. + and_return(@other_connection_impl) + @connection_impl. + should_receive(:swap). + once. + with(@other_connection_impl) + + @connection.swap @other_connection + end + +end + diff --git a/cpp/bindings/qpid/ruby/test/test_encoding.rb b/cpp/bindings/qpid/ruby/test/test_encoding.rb new file mode 100644 index 0000000000..060975a1d5 --- /dev/null +++ b/cpp/bindings/qpid/ruby/test/test_encoding.rb @@ -0,0 +1,146 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +$:.unshift File.join(File.dirname(__FILE__), "..", "lib") + +require 'test/unit' +require 'flexmock/test_unit' + +require 'cqpid' +require 'qpid/encoding' + +class TestEncoding < Test::Unit::TestCase + + def setup + @cqpid = flexmock(Cqpid) + + @message = flexmock("message") + @message_impl = flexmock("message_impl") + + @encoded = {"foo" => "bar"} + end + + def test_encode_map_with_symbols + @message. + should_receive(:message_impl). + once. + and_return(@message_impl) + @cqpid. + should_receive(:encode). + once. + with({"foo" => "bar"}, @message_impl). + and_return(@encoded) + + result = Qpid::Messaging.encode({:foo => :bar}, @message) + + assert_same @encoded, result + end + + def test_encode_list_with_symbols + @message. + should_receive(:message_impl). + once. + and_return(@message_impl) + @cqpid. + should_receive(:encode). + once. + with(["foo", "bar"], @message_impl). + and_return(@encoded) + + result = Qpid::Messaging.encode([:foo, :bar], @message) + + assert_same @encoded, result + end + + def test_encode_with_content_type + @message. + should_receive(:message_impl). + once. + and_return(@message_impl) + @cqpid. + should_receive(:encode). + once. + with({"foo" => "bar"}, @message_impl). + and_return(@encoded) + + result = Qpid::Messaging.encode({:foo => :bar}, @message) + + assert_same @encoded, result + end + + def test_encode + @message. + should_receive(:message_impl). + once. + and_return(@message_impl) + @cqpid. + should_receive(:encode). + once. + with({"foo" => "bar"}, @message_impl). + and_return(@encoded) + + result = Qpid::Messaging.encode({"foo" => "bar"}, @message) + + assert_same @encoded, result + end + + def test_decode_for_map + decoded = {"foo" => "bar"} + @message. + should_receive(:content_type). + once. + and_return("amqp/map") + @message. + should_receive(:message_impl). + once. + and_return(@message_impl) + @cqpid. + should_receive(:decodeMap). + once. + with(@message_impl). + and_return(decoded) + + result = Qpid::Messaging.decode(@message) + + assert_same decoded, result + end + + def test_decode_for_list + decoded = ["foo", "bar"] + @message. + should_receive(:content_type). + once. + and_return("amqp/list") + @message. + should_receive(:message_impl). + once. + and_return(@message_impl) + @cqpid. + should_receive(:decodeList). + once. + with(@message_impl). + and_return(decoded) + + result = Qpid::Messaging.decode(@message) + + assert_same decoded, result + end + +end + diff --git a/cpp/bindings/qpid/ruby/test/test_message.rb b/cpp/bindings/qpid/ruby/test/test_message.rb new file mode 100644 index 0000000000..3fc705bf7e --- /dev/null +++ b/cpp/bindings/qpid/ruby/test/test_message.rb @@ -0,0 +1,353 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +$:.unshift File.join(File.dirname(__FILE__), "..", "lib") + +require 'test/unit' +require 'flexmock/test_unit' + +require 'qpid' + +class TestMessage < Test::Unit::TestCase + + def setup + @address = flexmock("address") + @address_impl = flexmock("address_impl") + + @messaging = flexmock(Qpid::Messaging) + @message_impl = flexmock("message") + @message = Qpid::Messaging::Message.new({}, @message_impl) + end + + def test_message_impl + assert_same @message_impl, @message.message_impl + end + + def test_set_reply_to + @address. + should_receive(:address_impl). + once. + and_return(@address_impl) + @message_impl. + should_receive(:setReplyTo). + once. + with(@address_impl) + + @message.reply_to = @address + end + + def test_get_reply_to + @message_impl. + should_receive(:getReplyTo). + once. + and_return(@address_impl) + + result = @message.reply_to + + assert_not_nil result + assert_same @address_impl, result.address_impl + end + + def test_set_subject + @message_impl. + should_receive(:setSubject). + once. + with("New Subject") + + @message.subject = "New Subject" + end + + def test_get_subject + @message_impl. + should_receive(:getSubject). + once. + and_return("Old Subject") + + assert_equal "Old Subject", @message.subject + end + + def test_set_content_type + @message_impl. + should_receive(:setContentType). + once. + and_return("amqp/map") + + @message.content_type = "amqp/map" + end + + def test_get_content_type + @message_impl. + should_receive(:getContentType). + once. + and_return("amqp/list") + + assert_equal "amqp/list", @message.content_type + end + + def test_set_message_id + @message_impl. + should_receive(:setMessageId). + once. + with("717") + + @message.message_id = "717" + end + + def test_get_message_id + @message_impl. + should_receive(:getMessageId). + once. + and_return("1965") + + assert_equal "1965", @message.message_id + end + + def test_set_user_id + @message_impl. + should_receive(:setUserId). + once. + with("129") + + @message.user_id = "129" + end + + def test_get_user_id + @message_impl. + should_receive(:getUserId). + once. + and_return("1971") + + assert_equal "1971", @message.user_id + end + + def test_set_correlation_id + @message_impl. + should_receive(:setCorrelationId). + once. + with("320") + + @message.correlation_id = "320" + end + + def test_get_correlation_id + @message_impl. + should_receive(:getCorrelationId). + once. + and_return("1996") + + assert_equal "1996", @message.correlation_id + end + + def test_set_priority + @message_impl. + should_receive(:setPriority). + once. + with(9) + + @message.priority = 9 + end + + def test_get_priority + @message_impl. + should_receive(:getPriority). + once. + and_return(21) + + assert_equal 21, @message.priority + end + + def test_set_ttl + @message_impl. + should_receive(:setTtl). + once. + with(Qpid::Messaging::Duration::FOREVER) + + @message.ttl = Qpid::Messaging::Duration::FOREVER + end + + def test_get_ttl + @message_impl. + should_receive(:getTtl). + once. + and_return(Qpid::Messaging::Duration::SECOND) + + assert_equal Qpid::Messaging::Duration::SECOND, @message.ttl + end + + def test_set_durable + @message_impl. + should_receive(:setDurable). + once. + with(true) + + @message.durable = true + end + + def test_set_not_durable + @message_impl. + should_receive(:setDurable). + once. + with(false) + + @message.durable = false + end + + def test_get_durable + @message_impl. + should_receive(:getDurable). + once. + and_return(true) + + assert @message.durable + end + + def test_set_redelivered + @message_impl. + should_receive(:setRedelivered). + once. + with(true) + + @message.redelivered = true + end + + def test_set_not_redelivered + @message_impl. + should_receive(:setRedelivered). + once. + with(false) + + @message.redelivered = false + end + + def test_get_redelivered + @message_impl. + should_receive(:getRedelivered). + once. + and_return(false) + + assert !@message.redelivered + end + + def test_get_properties + properties = {"foo" => "bar"} + @message_impl. + should_receive(:getProperties). + once. + and_return(properties) + + result = @message.properties + + assert_equal properties, result + end + + def test_get_property + @message_impl. + should_receive(:getProperties). + once. + and_return({"foo" => "bar"}) + + result = @message["foo"] + + assert_equal "bar", result + end + + def test_set_property + @message_impl. + should_receive(:setProperty). + once. + with("foo", "bar") + + @message["foo"] = "bar" + end + + def test_set_content + @message_impl. + should_receive(:setContent). + once. + with("foo") + + @message.content = "foo" + assert_equal "foo", @message.content + end + + def test_set_content_with_array + content = ["one", "two", "three"] + + @messaging. + should_receive(:encode). + once. + with(content, @message, "amqp/list") + + @message.content = content + assert_same content, @message.content + end + + def test_set_content_with_map + content = {:foo => "bar", :dog => "cat"} + + @messaging. + should_receive(:encode). + once. + with(content, @message, "amqp/map") + + @message.content = content + assert_same content, @message.content + end + + def test_get_content + @message_impl. + should_receive(:getContent). + and_return("foo") + @message_impl. + should_receive(:getContentType). + and_return(String) + + assert_equal "foo", @message.content + end + + def test_get_content_with_array + decoded = ["foo", "bar"] + + @message_impl. + should_receive(:getContent). + and_return("[foo,bar]") + @message_impl. + should_receive(:getContentType). + and_return("amqp/list") + @messaging. + should_receive(:decode). + once. + with(@message, "amqp/list"). + and_return(decoded) + + result = @message.content + assert_same decoded, result + end + + def test_get_content_size + @message_impl. + should_receive(:getContentSize). + once. + and_return(68) + + assert_equal 68, @message.content_size + end + +end + diff --git a/cpp/bindings/qpid/ruby/test/test_receiver.rb b/cpp/bindings/qpid/ruby/test/test_receiver.rb new file mode 100644 index 0000000000..61a4db17f2 --- /dev/null +++ b/cpp/bindings/qpid/ruby/test/test_receiver.rb @@ -0,0 +1,238 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +$:.unshift File.join(File.dirname(__FILE__), "..", "lib") + +require 'test/unit' +require 'flexmock/test_unit' + +require 'qpid/receiver' + +class TestReceiver < Test::Unit::TestCase + + def setup + @session_impl = flexmock("session") + + @Message_class = flexmock(Qpid::Messaging::Message) + @Messaging_module = flexmock(Qpid::Messaging) + @message_impl = flexmock("message_impl") + @message = flexmock("message") + + @receiver_impl = flexmock("receiver") + @other_receiver = flexmock("other_receiver") + @other_receiver_impl = flexmock("other_receiver_impl") + @receiver = Qpid::Messaging::Receiver.new @receiver_impl + end + + def test_receiver_impl + assert_same @receiver_impl, @receiver.receiver_impl + end + + def test_get + @receiver_impl. + should_receive(:get). + once. + with_any_args. + and_return(@message_impl) + + result = @receiver.get + + assert_not_nil result + assert_same @message_impl, result.message_impl + end + + def test_get_with_duration + @receiver_impl. + should_receive(:get). + once. + with_any_args. + and_return(@message_impl) + + result = @receiver.get Qpid::Messaging::Duration::MINUTE + + assert_not_nil result + assert_same @message_impl, result.message_impl + end + + def test_get_with_no_message_received + @receiver_impl. + should_receive(:get). + once. + with_any_args. + and_return(nil) + + result = @receiver.get Qpid::Messaging::Duration::SECOND + + assert_nil result + end + + def test_fetch + @receiver_impl. + should_receive(:fetch). + once. + with_any_args. + and_return(@message_impl) + + result = @receiver.fetch + + assert_not_nil result + assert_same @message_impl, result.message_impl + end + + def test_fetch_with_duration + @receiver_impl. + should_receive(:fetch). + once. + with_any_args. + and_return(@message_impl) + + result = @receiver.fetch Qpid::Messaging::Duration::MINUTE + + assert_not_nil result + assert_same @message_impl, result.message_impl + end + + def test_fetch_with_no_message_received + @receiver_impl. + should_receive(:fetch). + once. + with_any_args. + and_return(nil) + + result = @receiver.fetch Qpid::Messaging::Duration::SECOND + + assert_nil result + end + + def test_set_capacity + @receiver_impl. + should_receive(:setCapacity). + once. + with(15) + + @receiver.capacity = 15 + end + + def test_get_capacity + @receiver_impl. + should_receive(:getCapacity). + once. + and_return(17) + + assert_equal 17, @receiver.capacity + end + + def test_get_available + @receiver_impl. + should_receive(:getAvailable). + once. + and_return(2) + + assert_equal 2, @receiver.available + end + + def test_get_unsettled + @receiver_impl. + should_receive(:getUnsettled). + once. + and_return(12) + + assert_equal 12, @receiver.unsettled + end + + def test_close + @receiver_impl. + should_receive(:close). + once + + @receiver.close + end + + def test_closed_when_open + @receiver_impl. + should_receive(:isClosed). + once. + and_return(false) + + assert !@receiver.closed? + end + + def test_closed + @receiver_impl. + should_receive(:isClosed). + once. + and_return(true) + + assert @receiver.closed? + end + + def test_get_name + @receiver_impl. + should_receive(:getName). + once. + and_return("my-queue") + + assert_equal "my-queue", @receiver.name + end + + def test_get_session + @receiver_impl. + should_receive(:getSession). + once. + and_return(@session_impl) + + result = @receiver.session + + assert_not_nil result + assert_same @session_impl, result.session_impl + end + + def test_is_valid + @receiver_impl. + should_receive(:isValid). + once. + and_return(false) + + assert !@receiver.valid? + end + + def test_is_null + @receiver_impl. + should_receive(:isNull). + once. + and_return(true) + + assert @receiver.null? + end + + def test_swap + @other_receiver. + should_receive(:receiver_impl). + once. + and_return(@other_receiver_impl) + @receiver_impl. + should_receive(:swap). + once. + with(@other_receiver_impl) + + @receiver.swap @other_receiver + end + +end + diff --git a/cpp/bindings/qpid/ruby/test/test_sender.rb b/cpp/bindings/qpid/ruby/test/test_sender.rb new file mode 100644 index 0000000000..64348b9f72 --- /dev/null +++ b/cpp/bindings/qpid/ruby/test/test_sender.rb @@ -0,0 +1,183 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +$:.unshift File.join(File.dirname(__FILE__), "..", "lib") + +require 'test/unit' +require 'flexmock/test_unit' + +require 'qpid/sender' + +class TestSender < Test::Unit::TestCase + + def setup + @messaging = flexmock(Qpid::Messaging) + @message = flexmock("message") + + @session_impl = flexmock("session_impl") + + @sender_impl = flexmock("sender_impl") + @other_sender_impl = flexmock("other_sender_impl") + @sender = Qpid::Messaging::Sender.new @sender_impl + @other_sender = flexmock("other_sender") + end + + def test_send + message_impl = "message_impl" + content = {:foo => :bar} + @message. + should_receive(:message_impl). + once. + and_return(message_impl) + @sender_impl. + should_receive(:send). + once. + with(message_impl, false) + + @sender.send @message + end + + def test_send_and_dont_block + message_impl = "message_impl" + content = {:foo => :bar} + @message. + should_receive(:message_impl). + once. + and_return(message_impl) + @sender_impl. + should_receive(:send). + once. + with(message_impl, false) + + @sender.send @message, :block => false + end + + def test_send_and_block + message_impl = "message_impl" + content = {:foo => :bar} + @message. + should_receive(:message_impl). + once. + and_return(message_impl) + @sender_impl. + should_receive(:send). + once. + with(message_impl, true) + + @sender.send @message, :block => true + end + + def test_close + @sender_impl. + should_receive(:close). + once + + @sender.close + end + + def test_set_capacity + @sender_impl. + should_receive(:setCapacity). + once. + with(17) + + @sender.capacity = 17 + end + + def test_get_capacity + @sender_impl. + should_receive(:getCapacity). + once. + and_return(12) + + assert_equal 12, @sender.capacity + end + + def test_unsettled + @sender_impl. + should_receive(:getUnsettled). + once. + and_return(5) + + assert_equal 5, @sender.unsettled + end + + def test_available + @sender_impl. + should_receive(:getAvailable). + once. + and_return(15) + + assert_equal 15, @sender.available + end + + def test_name + @sender_impl. + should_receive(:getName). + once. + and_return("myname") + + assert_equal "myname", @sender.name + end + + def test_session + @sender_impl. + should_receive(:getSession). + once. + and_return(@session_impl) + + result = @sender.session + + assert_not_nil result + assert_same @session_impl, result.session_impl + end + + def test_is_valid + @sender_impl. + should_receive(:isValid). + once. + and_return(true) + + assert @sender.valid? + end + + def test_is_null + @sender_impl. + should_receive(:isNull). + once. + and_return(false) + + assert !@sender.null? + end + + def test_swap + @other_sender. + should_receive(:sender_impl). + once. + and_return(@other_sender_impl) + @sender_impl. + should_receive(:swap). + once. + with(@other_sender_impl) + + @sender.swap @other_sender + end + +end + diff --git a/cpp/bindings/qpid/ruby/test/test_session.rb b/cpp/bindings/qpid/ruby/test/test_session.rb new file mode 100644 index 0000000000..20f055967b --- /dev/null +++ b/cpp/bindings/qpid/ruby/test/test_session.rb @@ -0,0 +1,445 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +$:.unshift File.join(File.dirname(__FILE__), "..", "lib") + +require 'test/unit' +require 'flexmock/test_unit' + +require 'qpid/errors' +require 'qpid/duration' +require 'qpid/session' + +class TestSession < Test::Unit::TestCase + + def setup + @session_impl = flexmock("session_impl") + @other_session = flexmock("other_session") + @other_session_impl = flexmock("other_session_impl") + @sender = flexmock("sender") + + @Connection_class = flexmock(Qpid::Messaging::Connection) + @connection_impl = flexmock("connection_impl") + @connection = flexmock("connection") + + @Receiver_class = flexmock(Qpid::Messaging::Receiver) + @receiver = flexmock("receiver") + @receiver_impl = flexmock("receiver_impl") + + @address = flexmock("address") + @address_impl = flexmock("address_impl") + + @Sender_class = flexmock(Qpid::Messaging::Sender) + @sender = flexmock("sender") + @sender_impl = flexmock("sender_impl") + + @message = flexmock("message") + @message_impl = flexmock("message_impl") + + @duration = flexmock("duration") + @duration_impl = flexmock("duration_impl") + + @session = Qpid::Messaging::Session.new(@session_impl) + end + + def test_create_sender_with_Address + @address. + should_receive(:class). + once. + and_return(Qpid::Messaging::Address). + should_receive(:address_impl). + once. + and_return(@address_impl) + @session_impl. + should_receive(:createSender). + once. + with(@address_impl). + and_return(@sender_impl) + + result = @session.create_sender @address + + assert_not_nil result + end + + def test_create_sender + @session_impl. + should_receive(:createSender). + once. + with_any_args. + and_return(@sender_impl) + + result = @session.create_sender("my-queue") + + assert_not_nil result + end + + def test_create_sender_with_address_string + @session_impl. + should_receive(:createSender). + once. + with("my-queue;{create:always}"). + and_return(@sender_impl) + + result = @session.create_sender "my-queue;{create:always}" + + assert_same @sender_impl, result.sender_impl + end + + def test_create_receiver + @address. + should_receive(:class). + once. + and_return(Qpid::Messaging::Address). + should_receive(:address_impl). + once. + and_return(@address_impl) + @session_impl. + should_receive(:createReceiver). + once. + with(@address_impl). + and_return(@receiver_impl) + + result = @session.create_receiver(@address) + + assert_equal @receiver_impl, result.receiver_impl + end + + def test_create_receiver_with_address_string + @session_impl. + should_receive(:createReceiver). + once. + with("my-queue"). + and_return(@receiver_impl) + + result = @session.create_receiver("my-queue") + + assert_same @receiver_impl, result.receiver_impl + end + + def test_close + @session_impl. + should_receive(:close). + once + + @session.close + end + + def test_commit + @session_impl. + should_receive(:commit). + once + + @session.commit + end + + def test_rollback + @session_impl. + should_receive(:rollback). + once + + @session.rollback + end + + def test_acknowledge_with_no_args + @session_impl. + should_receive(:acknowledge). + once. + with(false) + + @session.acknowledge + end + + def test_acknowledge_and_sync + @session_impl. + should_receive(:acknowledge). + once. + with(true) + + @session.acknowledge :sync => true + end + + def test_acknowledge_and_dont_sync + @session_impl. + should_receive(:acknowledge). + once. + with(false) + + @session.acknowledge :sync => false + end + + def test_acknowledge_message_without_sync + @message. + should_receive(:message_impl). + once. + and_return(@message_impl) + @session_impl. + should_receive(:acknowledge). + once. + with(@message_impl, false) + + @session.acknowledge :message => @message + end + + def test_acknowledge_message_and_sync + @message. + should_receive(:message_impl). + once. + and_return(@message_impl) + @session_impl. + should_receive(:acknowledge). + once. + with(@message_impl, true) + + @session.acknowledge :message => @message, :sync => true + end + + def test_acknowledge_message_and_dont_sync + @message. + should_receive(:message_impl). + once. + and_return(@message_impl) + @session_impl. + should_receive(:acknowledge). + once. + with(@message_impl, false) + + @session.acknowledge :message => @message, :sync => false + end + + def test_reject_message + @message. + should_receive(:message_impl). + once. + and_return(@message_impl) + @session_impl. + should_receive(:reject). + once. + with(@message_impl) + + @session.reject @message + end + + def test_release_message + @message. + should_receive(:message_impl). + once. + and_return(@message_impl) + @session_impl. + should_receive(:release). + once. + with(@message_impl) + + @session.release @message + end + + def test_sync_without_block + @session_impl. + should_receive(:sync). + once + + @session.sync + end + + def test_sync_and_block + @session_impl. + should_receive(:sync). + once. + with(true) + + @session.sync :block => true + end + + def test_sync_and_dont_block + @session_impl. + should_receive(:sync). + once. + with(false) + + @session.sync :block => false + end + + def test_receivable + @session_impl. + should_receive(:getReceivable). + once. + and_return(5) + + assert_equal 5, @session.receivable + end + + def test_unsettled_acks + @session_impl. + should_receive(:getUnsettledAcks). + once. + and_return(17) + + assert_equal 17, @session.unsettled_acks + end + + def test_next_receiver_with_no_duration + @session_impl. + should_receive(:nextReceiver). + once. + with(Qpid::Messaging::Duration::FOREVER.duration_impl). + and_return(@receiver_impl) + + result = @session.next_receiver + + assert_same @receiver_impl, result.receiver_impl + end + + def test_next_receiver_with_duration + @duration. + should_receive(:duration_impl). + once. + and_return(@duration_impl) + @session_impl. + should_receive(:nextReceiver). + once. + with(@duration_impl). + and_return(@receiver_impl) + + result = @session.next_receiver @duration + + assert_same @receiver_impl, result.receiver_impl + end + + def test_sender + @session_impl. + should_receive(:getSender). + once. + with("farkle"). + and_return(@sender_impl) + @Sender_class. + should_receive(:for_impl). + once. + with(@sender_impl). + and_return(@sender) + + result = @session.sender "farkle" + + assert_same @sender, result + end + + def test_sender_with_invalid_name + @session_impl. + should_receive(:getSender). + once. + with("farkle"). + and_throw(RuntimeError) + + assert_raise(Qpid::Messaging::KeyError) {@session.sender "farkle"} + end + + def test_receiver + @session_impl. + should_receive(:getReceiver). + once. + with("farkle"). + and_return(@receiver_impl) + @Receiver_class. + should_receive(:for_impl). + once. + with(@receiver_impl). + and_return(@receiver) + + result = @session.receiver "farkle" + + assert_same @receiver, result + end + + def test_receiver_with_invalid_name + @session_impl. + should_receive(:getReceiver). + once. + with("farkle"). + and_throw(RuntimeError) + + assert_raise(Qpid::Messaging::KeyError) {@session.receiver "farkle"} + end + + def test_connection + @session_impl. + should_receive(:getConnection). + once. + and_return(@connection_impl) + + result = @session.connection + + assert_same @connection_impl, result.connection_impl + end + + def test_error_with_none + @session_impl. + should_receive(:hasError). + once. + and_return(false) + + assert !@session.error? + end + + def test_error + @session_impl. + should_receive(:hasError). + once. + and_return(true) + + assert @session.error? + end + + def test_check_error + @session_impl. + should_receive(:checkError). + once + + @session.check_error + end + + def test_is_valid + @session_impl. + should_receive(:isValid). + once. + and_return(false) + + assert !@session.valid? + end + + def test_is_null + @session_impl. + should_receive(:isNull). + once. + and_return(false) + + assert !@session.null? + end + + def test_swap + @other_session. + should_receive(:session_impl). + once. + and_return(@other_session_impl) + @session_impl. + should_receive(:swap). + once. + with(@other_session_impl) + + @session.swap @other_session + end + +end diff --git a/cpp/bindings/qpid/ruby/test/ts_bindings.rb b/cpp/bindings/qpid/ruby/test/ts_bindings.rb new file mode 100644 index 0000000000..7aa410c8f8 --- /dev/null +++ b/cpp/bindings/qpid/ruby/test/ts_bindings.rb @@ -0,0 +1,30 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# + +$:.unshift File.join(File.dirname(__FILE__), "..", "lib") + +require 'test/unit' +require 'test_encoding' +require 'test_address' +require 'test_message' +require 'test_sender' +require 'test_receiver' +require 'test_session' +require 'test_connection' + -- cgit v1.2.1