azure 0.7.1 → 0.7.3

data/test/integration/service_bus/queues_test.rb

@@ -1,266 +0,0 @@
-#-------------------------------------------------------------------------
-# # Copyright (c) Microsoft and contributors. All rights reserved.
-#
-# Licensed 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.
-#--------------------------------------------------------------------------
-require 'integration/test_helper'
-
-describe 'ServiceBus Queues' do
-
-  subject { Azure::ServiceBus::ServiceBusService.new }
-  let(:queue_name) { ServiceBusQueueNameHelper.name }
-  let(:name_alternative) { ServiceBusQueueNameHelper.name }
-  let(:description) {{
-    :default_message_time_to_live => 'P10675199DT2H48M5.4775807S',
-    :duplicate_detection_history_time_window => 'PT10M',
-    :dead_lettering_on_message_expiration => "false",
-    :lock_duration => 'PT30S',
-    :max_delivery_count => "10",
-    :max_size_in_megabytes => "1",
-    :requires_duplicate_detection => "true",
-    :requires_session => "false"
-  }}
-  let(:description_alternative) {{
-    :lock_duration => 'PT30S',
-    :max_size_in_megabytes => 2048,
-    :requires_duplicate_detection => true,
-    :requires_session => true,
-    :default_message_time_to_live => 'PT30M',
-    :dead_lettering_on_message_expiration => true,
-    :duplicate_detection_history_time_window => 'PT20M',
-    :max_delivery_count => 20,
-    :enable_batched_operations => true
-  }}
-
-  after { ServiceBusQueueNameHelper.clean }
-
-  it "should be able to create a new queue from a string" do
-    queue = subject.create_queue queue_name
-    queue.must_be_kind_of Azure::ServiceBus::Queue
-    queue.name.must_equal queue_name
-  end
-
-  it "should be able to create a new queue from a Queue" do
-    queue = subject.create_queue Azure::ServiceBus::Queue.new(queue_name)
-    queue.must_be_kind_of Azure::ServiceBus::Queue
-    queue.name.must_equal queue_name
-  end
-
-  it "should be able to create a new queue from a string and description Hash" do
-    queue = subject.create_queue name_alternative, description_alternative
-    queue.must_be_kind_of Azure::ServiceBus::Queue
-    queue.name.must_equal name_alternative
-
-    queue.lock_duration.must_equal 30.0
-    queue.max_size_in_megabytes.must_equal description_alternative[:max_size_in_megabytes]
-    queue.requires_duplicate_detection.must_equal description_alternative[:requires_duplicate_detection]
-    queue.requires_session.must_equal description_alternative[:requires_session]
-    queue.default_message_time_to_live.must_equal 1800.0
-    queue.dead_lettering_on_message_expiration.must_equal description_alternative[:dead_lettering_on_message_expiration]
-    queue.duplicate_detection_history_time_window.must_equal 1200.0
-    queue.max_delivery_count.must_equal description_alternative[:max_delivery_count]
-    queue.enable_batched_operations.must_equal description_alternative[:enable_batched_operations]
-  end
-
-  it "should be able to create a new queue from a Queue with a description Hash" do
-    queue = subject.create_queue Azure::ServiceBus::Queue.new(name_alternative, description_alternative)
-    queue.must_be_kind_of Azure::ServiceBus::Queue
-    queue.name.must_equal name_alternative
-
-    queue.lock_duration.must_equal 30.0
-    queue.max_size_in_megabytes.must_equal description_alternative[:max_size_in_megabytes]
-    queue.requires_duplicate_detection.must_equal description_alternative[:requires_duplicate_detection]
-    queue.requires_session.must_equal description_alternative[:requires_session]
-    queue.default_message_time_to_live.must_equal 1800.0
-    queue.dead_lettering_on_message_expiration.must_equal description_alternative[:dead_lettering_on_message_expiration]
-    queue.duplicate_detection_history_time_window.must_equal 1200.0
-    queue.max_delivery_count.must_equal description_alternative[:max_delivery_count]
-    queue.enable_batched_operations.must_equal description_alternative[:enable_batched_operations]
-  end
-
-  describe 'when a queue exists' do
-    before { subject.create_queue queue_name }
-
-    describe '#delete_queue' do
-      it "should raise exception if the queue cannot be deleted" do
-        assert_raises(Azure::Core::Http::HTTPError) do
-          subject.delete_queue ServiceBusQueueNameHelper.name
-        end
-      end
-
-      it "should be able to delete the queue" do
-        response = subject.delete_queue queue_name
-        response.must_equal nil
-      end
-    end
-
-    describe "#get_queue" do
-      it "should be able to get a queue by name" do
-        result = subject.get_queue queue_name
-
-        result.must_be_kind_of Azure::ServiceBus::Queue
-        result.name.must_equal queue_name
-      end
-
-      it "if the queue doesn't exists it should throw" do
-        assert_raises(Azure::Core::Http::HTTPError) do
-          subject.get_queue ServiceBusQueueNameHelper.name
-        end
-      end
-    end
-
-    describe 'when there are multiple queues' do
-      let(:name1) { ServiceBusQueueNameHelper.name }
-      let(:name2) { ServiceBusQueueNameHelper.name }
-      before {
-        subject.create_queue name1
-        subject.create_queue name2
-      }
-
-      it "should be able to get a list of queues" do
-        result = subject.list_queues
-
-        result.must_be :kind_of?, Array
-        q_found = false
-        q1_found = false
-        q2_found = false
-        result.each { |q|
-          q_found = true if q.name == queue_name
-          q1_found = true if q.name == name1
-          q2_found = true if q.name == name2
-        }
-        assert (q_found and q1_found and q2_found), "list_queues did not return expected queues"
-      end
-
-      it "should be able to use $skip token with list_queues" do
-        result = subject.list_queues
-        result2 = subject.list_queues({ :skip => 1 })
-        result2.length.must_equal result.length - 1
-        result2[0].id.must_equal result[1].id
-      end
-
-      it "should be able to use $top token with list_queues" do
-        result = subject.list_queues
-        result.length.wont_equal 1
-
-        result2 = subject.list_queues({ :top => 1 })
-        result2.length.must_equal 1
-      end
-
-      it "should be able to use $skip and $top token together with list_queues" do
-        result = subject.list_queues
-        result2 = subject.list_queues({ :skip => 1, :top => 1 })
-        result2.length.must_equal 1
-        result2[0].id.must_equal result[1].id
-      end
-    end
-
-    it "should be able to send a message to a queue" do
-      msg = Azure::ServiceBus::BrokeredMessage.new("some text") do |m|
-        m.to = "yo"
-      end
-      res = subject.send_queue_message queue_name, msg
-      res.must_be_nil
-    end
-
-    describe "when the queue has messages" do
-      let(:messageContent) { 'messagecontent' }
-      let(:to) { 'yo' }
-      let(:label) { 'my_label' }
-      let(:properties) {{
-        "CustomDoubleProperty" => 3.141592,
-        "CustomInt32Property" => 37,
-        "CustomInt64Property" => 2**32,
-        "CustomInt64NegProperty" => -(2**32),
-        "CustomStringProperty" => "CustomPropertyValue",
-        "CustomDateProperty" => Time.now,
-        "CustomTrueProperty" => true,
-        "CustomFalseProperty" => false,
-        "CustomNilProperty" => nil,
-        "CustomJSONProperty" => "testingpa\n\"{}\\rtition"
-      }}
-      let(:msg) { m = Azure::ServiceBus::BrokeredMessage.new(messageContent, properties); m.to = 'me'; m }
-
-      before { subject.send_queue_message queue_name, msg }
-
-      it "should be able to peek a message from a queue" do
-        retrieved = subject.peek_lock_queue_message queue_name
-        retrieved.must_be :kind_of?, Azure::ServiceBus::BrokeredMessage
-
-        retrieved.body.must_equal msg.body
-        retrieved.to.must_equal msg.to
-        retrieved.label.must_equal msg.label
-
-        properties.each { |k,v|
-          unless properties[k].class == Time
-            retrieved.properties[k.downcase].must_equal properties[k]
-          else
-            # Time comes back as string as there is no good way to distinguish
-            retrieved.properties[k.downcase].to_s.must_equal properties[k].httpdate
-          end
-        }
-
-        refute retrieved.lock_token.nil?
-        refute retrieved.sequence_number.nil?
-      end
-
-      it "should be able to read-delete a message from a queue" do
-        retrieved = subject.read_delete_queue_message queue_name
-
-        retrieved.must_be :kind_of?, Azure::ServiceBus::BrokeredMessage
-        retrieved.body.must_equal msg.body
-        retrieved.to.must_equal msg.to
-
-        # it should be deleted
-        retrieved = subject.read_delete_queue_message queue_name, { :timeout => 2 }
-        retrieved.must_be_nil
-      end
-
-      it "should be able to unlock a message from a queue" do
-        retrieved = subject.peek_lock_queue_message queue_name, { :timeout => 2 }
-
-        # There shouldn't be an available message in the queue
-        retrieved2 = subject.peek_lock_queue_message queue_name, { :timeout => 2 }
-        retrieved2.must_be_nil
-
-        # Unlock the message
-        res = subject.unlock_queue_message retrieved
-        res.must_be_nil
-
-        # The message should be available once again
-        retrieved = subject.peek_lock_queue_message queue_name, { :timeout => 2 }
-        retrieved.body.must_equal msg.body
-      end
-
-      it "should be able to delete a message from a queue" do
-
-        retrieved = subject.peek_lock_queue_message queue_name
-        retrieved.body.must_equal msg.body
-
-        subject.delete_queue_message retrieved
-
-        # it should be deleted
-        retrieved = subject.peek_lock_queue_message queue_name, { :timeout => 2 }
-        assert_nil retrieved
-      end
-
-      it "should be able to read a message from a queue" do
-        subject.send_queue_message queue_name, msg
-        retrieved = subject.receive_queue_message queue_name
-
-        retrieved.must_be :kind_of?, Azure::ServiceBus::BrokeredMessage
-        retrieved.body.must_equal msg.body
-        retrieved.to.must_equal msg.to
-      end
-    end
-  end
-end

data/test/integration/service_bus/relay_test.rb

@@ -1,132 +0,0 @@
-#-------------------------------------------------------------------------
-# # Copyright (c) Microsoft and contributors. All rights reserved.
-#
-# Licensed 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.
-#--------------------------------------------------------------------------
-require "integration/test_helper"
-
-describe "ServiceBus Relay" do
-
-  subject { Azure::ServiceBus::ServiceBusService.new }
-  let(:bus_name) { ServiceBusRelayNameHelper.name }
-  let(:name_alternative) { ServiceBusRelayNameHelper.name }
-  let(:description) {{
-    :relay_type => 'Http',
-    :requires_client_authorization => true,
-    :requires_transport_security => true
-  }}
-  let(:description_alternative) {{
-    :relay_type => 'NetTcp',
-    :requires_client_authorization => false,
-    :requires_transport_security => false
-  }}
-
-  after { ServiceBusRelayNameHelper.clean }
-
-  it "should be able to create a new relay endpoint from a string and description Hash" do
-    relay = subject.create_relay name_alternative, description_alternative
-    relay.must_be_kind_of Azure::ServiceBus::Relay
-    relay.name.must_equal name_alternative
-
-    relay.relay_type.must_equal description_alternative[:relay_type]
-    relay.requires_client_authorization.must_equal description_alternative[:requires_client_authorization]
-    relay.requires_transport_security.must_equal description_alternative[:requires_transport_security]
-  end
-
-  it "should be able to create a new relay from a Relay with a description Hash" do
-    relay = subject.create_relay Azure::ServiceBus::Relay.new(name_alternative, description_alternative)
-    relay.must_be_kind_of Azure::ServiceBus::Relay
-    relay.name.must_equal name_alternative
-
-    relay.relay_type.must_equal description_alternative[:relay_type]
-    relay.requires_client_authorization.must_equal description_alternative[:requires_client_authorization]
-    relay.requires_transport_security.must_equal description_alternative[:requires_transport_security]
-  end
-
-  describe 'when a relay exists' do
-    before { subject.create_relay bus_name, description }
-
-    describe "#get_relay" do
-      it "should be able to get a relay by name" do
-        result = subject.get_relay bus_name
-
-        result.must_be_kind_of Azure::ServiceBus::Relay
-        result.name.must_equal bus_name
-      end
-
-      it "if the relay endpoint doesn't exists it should throw" do
-        assert_raises(Azure::Core::Http::HTTPError) do
-          subject.get_relay ServiceBusRelayNameHelper.name
-        end
-      end
-    end
-
-    describe '#delete_relay' do
-      it "should raise exception if the relay endpoint cannot be deleted" do
-        assert_raises(Azure::Core::Http::HTTPError) do
-          subject.delete_relay ServiceBusRelayNameHelper.name
-        end
-      end
-
-      it "should be able to delete the relay endpoint" do
-        response = subject.delete_relay bus_name
-        response.must_equal nil
-      end
-    end
-
-    describe 'when there are multiple relay endpoints' do
-      let(:name1) { ServiceBusRelayNameHelper.name }
-      let(:name2) { ServiceBusRelayNameHelper.name }
-      before {
-        subject.create_relay name1, description
-        subject.create_relay name2, description_alternative
-      }
-
-      it "should be able to get a list of relays" do
-        result = subject.list_relays
-
-        result.must_be :kind_of?, Array
-        q_found = false
-        q1_found = false
-        q2_found = false
-        result.each { |q|
-          q_found = true if q.name == bus_name
-          q1_found = true if q.name == name1
-          q2_found = true if q.name == name2
-        }
-        assert (q_found and q1_found and q2_found), "list_relays did not return expected relay endpoints"
-      end
-
-      it "should be able to use $skip token with list_relays" do
-        result = subject.list_relays
-        result2 = subject.list_relays({ :skip => 1 })
-        result2.length.must_equal result.length - 1
-        result2[0].id.must_equal result[1].id
-      end
-
-      it "should be able to use $top token with list_relays" do
-        result = subject.list_relays
-        result.length.wont_equal 1
-
-        result2 = subject.list_relays({ :top => 1 })
-        result2.length.must_equal 1
-      end
-
-      it "should be able to use $skip and $top token together with list_relays" do
-        result = subject.list_relays
-        result2 = subject.list_relays({ :skip => 1, :top => 1 })
-        result2.length.must_equal 1
-        result2[0].id.must_equal result[1].id
-      end
-    end
-  end
-end

data/test/integration/service_bus/rules_test.rb

@@ -1,145 +0,0 @@
-#-------------------------------------------------------------------------
-# # Copyright (c) Microsoft and contributors. All rights reserved.
-#
-# Licensed 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.
-#--------------------------------------------------------------------------
-require "integration/test_helper"
-
-describe "ServiceBus Rules" do
-  subject { Azure::ServiceBus::ServiceBusService.new }
-  after { ServiceBusTopicNameHelper.clean }
-  let(:topic){ ServiceBusTopicNameHelper.name }
-  let(:subscription){ "mySubscription" }
-  let(:rule){ "myRule" }
-
-  before {
-    subject.create_topic topic
-    subject.create_subscription topic, subscription
-  }
-
-  it "should be able to create a new rule" do
-    result = subject.create_rule topic, subscription, rule
-    result.must_be :kind_of?, Azure::ServiceBus::Rule
-    result.filter.must_be_kind_of Azure::ServiceBus::TrueFilter
-    result.filter.sql_expression.must_equal "1=1"
-    result.filter.compatibility_level.must_equal 20
-  end
-
-  it "should be able to create a new rule object" do
-    ruleObject = Azure::ServiceBus::Rule.new "my_other_rule"
-    ruleObject.subscription = subscription
-    ruleObject.topic = topic
-
-    result = subject.create_rule ruleObject
-    result.must_be :kind_of?, Azure::ServiceBus::Rule
-    result.filter.must_be_kind_of Azure::ServiceBus::TrueFilter
-    result.filter.sql_expression.must_equal "1=1"
-    result.filter.compatibility_level.must_equal 20
-
-    subject.delete_rule result
-  end
-
-  it "should be able to create a new rule with an action" do
-    ruleObject = Azure::ServiceBus::Rule.new "my_other_rule"
-    ruleObject.subscription = subscription
-    ruleObject.topic = topic
-    ruleObject.filter = Azure::ServiceBus::SqlFilter.new({ :sql_expression => "MyProperty='XYZ'" })
-    ruleObject.action = Azure::ServiceBus::SqlRuleAction.new({ :sql_expression => "set MyProperty2 = 'ABC'" })
-
-    result = subject.create_rule ruleObject
-    result.must_be :kind_of?, Azure::ServiceBus::Rule
-    result.filter.must_be_kind_of Azure::ServiceBus::SqlFilter
-    result.filter.sql_expression.must_equal "MyProperty='XYZ'"
-    result.filter.compatibility_level.must_equal 20
-
-    result.action.must_be_kind_of Azure::ServiceBus::SqlRuleAction
-    result.action.sql_expression.must_equal "set MyProperty2 = 'ABC'"
-    result.action.compatibility_level.must_equal 20
-
-    subject.delete_rule result
-  end
-
-  it "should be able to create a new rule with a correlation filter" do
-    ruleObject = Azure::ServiceBus::Rule.new "my_other_rule"
-    ruleObject.subscription = subscription
-    ruleObject.topic = topic
-    ruleObject.filter = Azure::ServiceBus::CorrelationFilter.new({ :correlation_id => "identifier" })
-    ruleObject.action = Azure::ServiceBus::SqlRuleAction.new({ :sql_expression => "set MyProperty2 = 'ABC'" })
-
-    result = subject.create_rule ruleObject
-    result.must_be :kind_of?, Azure::ServiceBus::Rule
-    result.filter.must_be_kind_of Azure::ServiceBus::CorrelationFilter
-    result.filter.correlation_id.must_equal "identifier"
-
-    result.action.must_be_kind_of Azure::ServiceBus::SqlRuleAction
-    result.action.sql_expression.must_equal "set MyProperty2 = 'ABC'"
-    result.action.compatibility_level.must_equal 20
-
-    subject.delete_rule result
-  end
-
-  describe "when a rule exists" do
-    before { subject.create_rule topic, subscription, rule }
-
-    it "should be able to delete rules" do
-      subject.delete_rule topic, subscription, rule
-    end
-
-    it "should be able to get rules" do
-      result = subject.get_rule topic, subscription, rule
-      result.must_be :kind_of?, Azure::ServiceBus::Rule
-      result.filter.must_be_kind_of Azure::ServiceBus::TrueFilter
-      result.filter.sql_expression.must_equal "1=1"
-      result.filter.compatibility_level.must_equal 20
-    end
-
-    it "should be able to list rules" do
-      result = subject.list_rules topic, subscription
-      rule_found = false
-      result.each { |r|
-        rule_found = true if r.name == rule
-      }
-      assert rule_found, "list_rules didn't include the expected rule"
-    end
-
-    describe 'when multiple rules exist' do
-      let(:rule1) { "myRule1" }
-      let(:rule2) { "myRule2" }
-      before {
-        subject.create_rule topic, subscription, rule1
-        subject.create_rule topic, subscription, rule2
-      }
-
-      it "should be able to use $skip token" do
-        result = subject.list_rules topic, subscription
-        result2 = subject.list_rules topic, subscription, { :skip => 1 }
-        result2.length.must_equal result.length - 1
-        result2[0].id.must_equal result[1].id
-      end
-
-      it "should be able to use $top token" do
-        result = subject.list_rules topic, subscription
-        result.length.wont_equal 1
-
-        result2 = subject.list_rules topic, subscription, { :top => 1 }
-        result2.length.must_equal 1
-      end
-
-      it "should be able to use $skip and $top token together" do
-        result = subject.list_rules topic, subscription
-        result2 = subject.list_rules topic, subscription, { :skip => 1, :top => 1 }
-        result2.length.must_equal 1
-        result2[0].id.must_equal result[1].id
-      end
-    end
-  end
-end