azure 0.1.1 → 0.5.0

data/test/integration/service_bus/queues_test.rb

@@ -0,0 +1,266 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft. 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(: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 name
+    queue.must_be_kind_of Azure::ServiceBus::Queue
+    queue.name.must_equal name
+  end
+
+  it "should be able to create a new queue from a Queue" do
+    queue = subject.create_queue Azure::ServiceBus::Queue.new(name)
+    queue.must_be_kind_of Azure::ServiceBus::Queue
+    queue.name.must_equal 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 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 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 name
+
+        result.must_be_kind_of Azure::ServiceBus::Queue
+        result.name.must_equal 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 == 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 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 name, msg }
+      
+      it "should be able to peek a message from a queue" do
+        retrieved = subject.peek_lock_queue_message 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 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 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 name, { :timeout => 2 }
+
+        # There shouldn't be an available message in the queue
+        retrieved2 = subject.peek_lock_queue_message 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 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 name
+        retrieved.body.must_equal msg.body
+
+        subject.delete_queue_message retrieved
+
+        # it should be deleted
+        retrieved = subject.peek_lock_queue_message name, { :timeout => 2 }
+        assert_nil retrieved
+      end
+
+      it "should be able to read a message from a queue" do
+        subject.send_queue_message name, msg
+        retrieved = subject.receive_queue_message 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/rules_test.rb

@@ -0,0 +1,145 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft. 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

data/test/integration/service_bus/scenario_test.rb

@@ -0,0 +1,102 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft. 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"
+
+require "azure/service_bus/brokered_message"
+
+class ScenarioHelper
+  def ScenarioHelper.out (s)
+    if (false)
+      print s + "\n"
+    end
+  end
+
+  def ScenarioHelper.get_custom_properties(i)
+    custom_properties             = {}
+    custom_properties['i']        = i;
+    custom_properties['test']     = Time.local(2001, i, 1)
+    custom_properties['name']     = 'Test' + i.to_s;
+    custom_properties['meanname'] = "'\"Me`\\'&*<>!@#%^*)\n" + i.to_s;
+    custom_properties['int']      = 50 + i;
+    custom_properties['float']    = 3.14159 + i;
+    custom_properties['even']     = (i % 2 == 0);
+    custom_properties;
+  end
+
+  def ScenarioHelper.create_issue_message(issue_id, issue_body, label)
+    message = Azure::ServiceBus::BrokeredMessage.new(issue_body)
+
+    message.correlation_id  = "correlationid" + label
+    message.delivery_count  = 1
+    message.sequence_number = 12
+    message.content_type    = 'text/xml'
+    message.label           = label
+    message.to              = '1@1.com'
+    message.message_id      = issue_id
+
+    custom_properties = ScenarioHelper.get_custom_properties issue_id.to_i
+    custom_properties.each { |key, value|
+      message.properties[key] = value
+    }
+
+    message
+  end
+
+  def ScenarioHelper.compare_messages(expected, actual, custom_properties = nil)
+    actual.body.must_equal                       expected.body
+    actual.content_type.must_equal               expected.content_type
+    actual.correlation_id.must_equal             expected.correlation_id
+    actual.enqueued_time_utc.must_equal          expected.enqueued_time_utc
+    actual.label.must_equal                      expected.label
+    actual.message_id.must_equal                 expected.message_id
+    actual.reply_to.must_equal                   expected.reply_to
+    actual.reply_to_session_id.must_equal        expected.reply_to_session_id
+    actual.scheduled_enqueue_time_utc.must_equal expected.scheduled_enqueue_time_utc
+    actual.session_id.must_equal                 expected.session_id
+    actual.to.must_equal                         expected.to
+
+    # Note: The following properties are controlled by the server,
+    # so we cannot verify as much
+    actual.delivery_count.must_be :kind_of?, Integer
+    actual.sequence_number.must_be :kind_of?, Integer
+    if actual.lock_token != nil
+      actual.lock_token.must_be :kind_of?, String
+    end
+    if actual.locked_until_utc != nil
+      actual.locked_until_utc.must_be :kind_of?, Time
+    end
+
+    if custom_properties == nil
+      expected_properties = expected.properties;
+      index = expected_properties["i"];
+      if (index == nil)
+        index = 1;
+      end
+      custom_properties = get_custom_properties(index.to_i);
+    end
+
+    custom_properties.each { |key, value|
+      ScenarioHelper.out key + ":" + value.to_s
+      ScenarioHelper.out key.downcase + ":" + (actual.properties[key.downcase] == nil ? "<nil>" : actual.properties[key.downcase].to_s)
+      if value != "GUID"
+        if value != nil && value.class == Time
+          value.httpdate.must_equal actual.properties[key.downcase]
+        else
+          value.must_equal actual.properties[key.downcase]
+        end
+      end
+    }
+  end
+end