iron_mq 5.0.1 → 6.0.0.pre1

data/lib/iron_mq/response.rb

@@ -13,7 +13,7 @@ module IronMQ
     end
 
     def id
-      @raw["id"]
+      @raw['id']
     end
 
     def [](key)
@@ -21,7 +21,7 @@ module IronMQ
     end
 
     def msg
-      @raw["msg"]
+      @raw['msg']
     end
     #
     #def raw

data/lib/iron_mq/subscribers.rb

@@ -10,6 +10,10 @@ module IronMQ
       @options = options
     end
 
+    def name
+      @raw['name']
+    end
+
     def url
       @raw['url']
     end
@@ -20,7 +24,8 @@ module IronMQ
 
     # `options` was kept for backward compatibility
     def delete(options = {})
-      @message.call_api_and_parse_response(:delete, path)
+      @message.call_api_and_parse_response(:delete, path,
+                                           {subscriber_name: name})
     rescue Rest::HttpError => ex
       #if ex.code == 404
       #  Rest.logger.info("Delete got 404, safe to ignore.")
@@ -36,7 +41,7 @@ module IronMQ
     private
 
     def path
-      "/subscribers/#{id}"
+      "/subscribers/#{name}"
     end
   end
 

data/lib/iron_mq/version.rb

@@ -1,4 +1,4 @@
 module IronMQ
-  VERSION = "5.0.1"
+  VERSION = "6.0.0.pre1"
 end
 

data/test/Rakefile

@@ -0,0 +1,33 @@
+require 'tmpdir'
+require 'rake/testtask'
+
+Dir.chdir(File.dirname(__FILE__) + '/..')
+
+Rake::TestTask.new do |t|
+  if ENV['NEW_PROJECT']
+    require_relative '../lib/iron_worker_ng.rb'
+
+    client = IronWorkerNG::Client.new
+    name = 'IWtest ' + Time.now.strftime('%b %-d %T')
+    resp = client.api.post('projects', name: name)
+    res = JSON.parse(resp.body)
+    raise "Failed to create new project: #{res}" unless
+        res['msg'].start_with? 'Project Created'
+
+    ENV['IRON_PROJECT_ID'] = res['id']
+  end
+  if ENV['IRON_PROJECT_ID']
+    t.options = "-- --project-id=#{ENV['IRON_PROJECT_ID']}"
+  end
+
+  t.libs << "lib"
+
+  files = FileList['test/**/test_*.rb']
+  t.test_files = files.keep_if do |f|
+    f =~ Regexp.new(ENV['TESTP'] || '') and
+        not ( r = ENV['EXCLP'] and
+            f =~ Regexp.new(r) )
+  end
+
+  t.verbose = true
+end

data/test/quick_run.rb

@@ -27,8 +27,8 @@ class QuickRun < TestBase
         puts "post"
         res = queue.post(body)
         # p res
-        assert_not_nil res
-        assert_not_nil res.id
+        refute_nil res
+        refute_nil res.id
         post_id = res.id
         assert !(res.msg.nil? || res.msg.empty?)
       end
@@ -36,7 +36,7 @@ class QuickRun < TestBase
       quicky.time(:get) do
         puts "get"
         msg = queue.get
-        assert_not_nil msg.id
+        refute_nil msg.id
         assert_equal msg.id, post_id
         assert !(msg.body.nil? || msg.body.empty?)
         assert_equal body, msg.body
@@ -46,7 +46,7 @@ class QuickRun < TestBase
         puts "delete"
         res = queue.delete(post_id)
         # p res
-        assert_not_nil res
+        refute_nil res
         assert !(res.msg.nil? || res.msg.empty?)
       end
 

data/test/quick_run2.rb

@@ -59,8 +59,8 @@ class QuickRun < TestBase
         quicky.time(:post) do
           res = queue.post("hello world!")
           # p res
-          assert_not_nil res
-          assert_not_nil res.id
+          refute_nil res
+          refute_nil res.id
           post_id = res.id
           assert !(res.msg.nil? || res.msg.empty?)
         end

data/test/test_alerts.rb

@@ -17,61 +17,69 @@ class TestAlerts < TestBase
 
     # no configuration
     alert = {}
-    assert_raise(Rest::HttpError) { queue.add_alert(alert) }
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
 
     # only type is specified
     alert[:type] = 'fixed'
-    assert_raise(Rest::HttpError) { queue.add_alert(alert) }
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
 
     # type and trigger value specified
     alert[:trigger] = 30
-    assert_raise(Rest::HttpError) { queue.add_alert(alert) }
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
 
     # type, trigger, and direction
     alert[:direction] = 'asc'
-    assert_raise(Rest::HttpError) { queue.add_alert(alert) }
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
 
     # type, trigger, direction, and alert queue name - alright
     aq_name = 'bad-alerts-params-alerts'
     alert[:queue] = aq_name
     assert_nothing_raised(Rest::HttpError) { queue.add_alert(alert) }
 
-    # type, trigger, direction, queue name, and snooze - alright
+    # type, trigger, direction, queue name, and snooze - alert duplication
     alert[:snooze] = 8
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
+
+    # alright, no alert duplication
+    alert[:trigger] = 50
     assert_nothing_raised(Rest::HttpError) { queue.add_alert(alert) }
+    queue.clear_alerts
 
     # wrong snooze
     alert[:snooze] = -13
-    assert_raise(Rest::HttpError) { queue.add_alert(alert) }
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
 
     alert[:snooze] = '1234'
-    assert_raise(Rest::HttpError) { queue.add_alert(alert) }
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
 
     # wrong type
     alert[:snooze] = 0
     alert[:type] = 'wrong'
-    assert_raise(Rest::HttpError) { queue.add_alert(alert) }
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
 
     # wrong trigger
     alert[:type] = 'progressive'
     alert[:trigger] = 'c'
-    assert_raise(Rest::HttpError) { queue.add_alert(alert) }
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
 
     # wrong direction
     alert[:trigger] = 30
     alert[:direction] = 'both'
-    assert_raise(Rest::HttpError) { queue.add_alert(alert) }
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
 
-    # delete queue to clear
-    delete_queues queue
+    # default direction is "asc"
+    alert.delete(:direction)
+    assert_nothing_raised(Rest::HttpError) { queue.add_alert(alert) }
+
+    queue.clear_alerts
 
     # Test max alerts number
     alert[:direction] = 'asc'
     # insert 6 alerts
-    assert_raise(Rest::HttpError) { queue.add_alerts(Array.new(6, alert)) }
+    assert_raises(Rest::HttpError) { queue.add_alerts(Array.new(6, alert)) }
 
     queue.add_alerts(Array.new(5, alert))
-    assert_raise(Rest::HttpError) { queue.add_alert(alert) }
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
 
     delete_queues queue
 
@@ -79,14 +87,33 @@ class TestAlerts < TestBase
     # Progressive alert posts to its queue (queue is the same as alert queue)
     alert[:queue] = q_name
     alert[:type] = 'progressive'
-    assert_raise(Rest::HttpError) { queue.add_alert(alert) }
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
 
     # Q1 progressive alert posts to Q2, Q2 progressive alert posts to Q1
     a_queue = @client.queue aq_name
+    delete_queues a_queue
+
     queue.add_alert(alert.merge({:queue => aq_name}))
-    assert_raise(Rest::HttpError) do
+    assert_raises(Rest::HttpError) do
       a_queue.add_alert(alert.merge({:queue => q_name}))
     end
+
+    delete_queues queue, a_queue
+
+    # Push queues have no alerts feature
+    queue = @client.queue 'push_queue'
+    delete_queues queue
+
+    queue.add_subscriber({ :url => 'http://iron.io/receiver' })
+    assert_raises(Rest::HttpError) { queue.add_alert(alert) }
+
+    delete_queues queue
+
+    assert_nothing_raised(Rest::HttpError) { queue.add_alert(alert) }
+    # conversion queue with alerts to push queue must raise exception
+    assert_raises(Rest::HttpError) { queue.update({ :push_type => 'multicast' }) }
+
+    delete_queues queue
   end
 
   def test_size_alerts
@@ -141,15 +168,19 @@ class TestAlerts < TestBase
 
     # Trigger alert
     post_messages(queue, trigger + 1)
-    to_time = Time.now + snooze - 4
+    to_time = Time.now + snooze - 2
     assert_queue_size 1, alert_queue
 
-    while (lambda { Time.now }).call < to_time do
+    while true do
       delete_messages(queue, 2) # queeu size is `trigger - 1`
       post_messages(queue, 2) # size is `trigger + 1`
-      assert_queue_size 1, alert_queue
+      if Time.now < to_time
+        assert_queue_size 1, alert_queue
+      else
+        break
+      end
     end
-    sleep 4
+    sleep 2
 
     delete_messages(queue, 2) # queeu size is `trigger - 1`
     post_messages(queue, 2) # size is `trigger - 1`
@@ -163,15 +194,19 @@ class TestAlerts < TestBase
     # Trigger alert
     post_messages(queue, trigger + 1)
     delete_messages(queue, 2)
-    to_time = Time.now + snooze - 4
+    to_time = Time.now + snooze - 2
     assert_queue_size 1, alert_queue
 
-    while (lambda { Time.now }).call < to_time do
+    while true do
       post_messages(queue, 2) # queeu size is `trigger + 1`
       delete_messages(queue, 2) # size is `trigger - 1`
-      assert_queue_size 1, alert_queue
+      if Time.now < to_time
+        assert_queue_size 1, alert_queue
+      else
+        break
+      end
     end
-    sleep 4
+    sleep 2
 
     post_messages(queue, 2) # size is `trigger + 1`
     delete_messages(queue, 2) # queeu size is `trigger - 1`
@@ -235,11 +270,15 @@ class TestAlerts < TestBase
     # Check queue for alert
     assert_queue_size 1, alert_queue
 
-    while (lambda { Time.now }).call < to_time do
+    while true do
       # will trigger alert if snooze does not work
       post_messages(queue, trigger + 1)
       # but must not trigger
-      assert_queue_size 1, alert_queue
+      if Time.now < to_time
+        assert_queue_size 1, alert_queue
+      else
+        break
+      end
     end
     sleep 4
 
@@ -250,18 +289,24 @@ class TestAlerts < TestBase
     delete_queues(queue, alert_queue)
 
     # test descending alert with snooze
-    queue, alert_queue = clear_queue_add_alert(type, 2, 'desc', snooze)
+    queue, alert_queue = clear_queue_add_alert(type, 1, 'desc', snooze)
 
     # Does not trigger alert
     post_messages(queue, 20 * trigger)
-    to_time = Time.now + snooze - 4
+    to_time = Time.now + snooze - 3
 
-    while (lambda { Time.now }).call < to_time do
+    while true do
       delete_messages(queue, trigger + 1)
-      assert_queue_size 1, alert_queue
+      amsgs = alert_queue.peek({ :n => 10 })
+      puts amsgs.map { |am| am.body }.join("\n")
+      if Time.now < to_time
+        assert_queue_size 1, alert_queue
+      else
+        break
+      end
       break if get_queue_size(queue) <= trigger
     end
-    sleep 4
+    sleep 3
 
     post_messages(queue, trigger + 1)
     delete_messages(queue, trigger)
@@ -293,7 +338,7 @@ class TestAlerts < TestBase
   def delete_queues(*queues)
     queues.each do |q|
       begin
-        q.delete_queue
+        q.delete
       rescue Rest::HttpError => ex
         if ex.code == 404
           Rest.logger.info("Delete queue got 404, ignoring.")
@@ -323,6 +368,7 @@ class TestAlerts < TestBase
       puts "Try to trigger descending alert... delete #{nmsgs} messages"
       delete_messages(queue, nmsgs)
     end
+    sleep 1
     assert_queue_size aq_size, alert_queue, 'Alert is triggered, but must not be'
 
     if qsize < trigger
@@ -332,6 +378,7 @@ class TestAlerts < TestBase
       puts "Delete #{1 + overhead} more message(s)"
       delete_messages(queue, 1 + overhead)
     end
+    sleep 1
     assert_queue_size aq_size + 1, alert_queue, 'Alert is not triggered, but must be'
   end
 

data/test/test_base.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
-require 'test/unit'
+gem 'minitest'
+require 'minitest/autorun'
 require 'yaml'
 require 'uber_config'
 
@@ -14,7 +15,7 @@ LOG = Logger.new(STDOUT)
 LOG.level = Logger::INFO
 MAX_TRIES = 10
 
-class TestBase < Test::Unit::TestCase
+class TestBase < Minitest::Test
 
   def setup
     puts 'setup'
@@ -27,8 +28,8 @@ class TestBase < Test::Unit::TestCase
 
     @client = IronMQ::Client.new(@config['iron'])
     puts "IronMQ::VERSION = #{IronMQ::VERSION}"
-    #Rest.logger.level = Logger::DEBUG # this doesn't work for some reason?
-    #IronCore::Logger.logger.level = Logger::DEBUG
+    # Rest.logger.level = Logger::DEBUG # this doesn't work for some reason?
+    # IronCore::Logger.logger.level = Logger::DEBUG
 
     @queue_name = 'ironmq-ruby-tests' # default queue for tests
   end
@@ -46,6 +47,7 @@ class TestBase < Test::Unit::TestCase
     rescue Rest::HttpError => ex
       if ex.code == 404
         # this is fine
+        puts '404 ON CLEAR!!'
       else
         raise ex
       end

data/test/test_bulk.rb

@@ -10,7 +10,7 @@ class TestBulk < TestBase
   def test_bulk
     LOG.info "test_bulk"
 
-    q_name = 'ironmq-gem-bulk'
+    q_name = "ironmq-gem-bulk#{Time.now.to_i}"
     queue = @client.queue(q_name)
 
     times = 50

data/test/test_iron_mq.rb

@@ -7,36 +7,6 @@ class IronMQTests < TestBase
     super
     LOG.info "@host: #{@host}"
 
-    queues = @client.queues.list
-    # p queues
-  end
-
-  def test_performance_post_100_messages
-    queue = @client.queue('test_perf_100')
-    # slower to rackspace since this is running on aws
-    timeout = @host.include?('rackspace') ? 40 : 12
-
-    assert_performance(timeout) do
-      100.times do
-        queue.post("hello world!")
-      end
-
-      # delete queue on test complete
-      resp = queue.delete_queue
-      assert_equal 200, resp.code, "API must response with HTTP 200 status, but returned HTTP #{resp.code}"
-    end
-  end
-
-  def test_get
-    queue_name = "some_queue_abcj9u23"
-    queue = @client.queue(queue_name)
-    msg = queue.get
-    v = "hello big world"
-    queue.post(v)
-    msg = queue.get
-    msg.delete
-    msg = queue.get
-
   end
 
   def test_basics
@@ -44,8 +14,7 @@ class IronMQTests < TestBase
     clear_queue(queue_name)
 
     # NOTE: Kept for backward compatibility checking
-    queue = @client.queues.get(:name => queue_name)
-    # p queue
+    queue = @client.queue(queue_name)
     res = queue.post("hello world!")
     # p res
 
@@ -53,17 +22,16 @@ class IronMQTests < TestBase
     assert res.id
     assert res.msg
     sleep 0.3
-    assert_equal 1, queue.size
+    assert_equal 1, queue.reload.size
 
-    message = queue.get
+    message = queue.reserve
     # p res
     assert res["id"]
     assert res.id
 
-    res = queue.delete(res["id"])
+    res = queue.delete(res["id"], message.reservation_id)
     # p res
-    puts "shouldn't be any more"
-    res = queue.get
+    res = queue.reserve
     # p res
     assert_nil res
 
@@ -73,15 +41,14 @@ class IronMQTests < TestBase
     res = queue.post("hello world 2!")
     # p res
 
-    msg = queue.get
+    msg = queue.reserve
     # p msg
     assert msg
 
     res = msg.delete
     #p res
 
-    puts "shouldn't be any more"
-    res = queue.get
+    res = queue.reserve
     # p res
     assert_nil res
 
@@ -92,16 +59,16 @@ class IronMQTests < TestBase
     # p res
     assert res.msg
 
-    res = queue.get
-    # p res
+    res = queue.reserve
+    puts "queue.reserve got: #{res.body}"
+    p res
     assert res["id"]
     assert res.id
     assert_equal v, res.body
 
-    res = queue.delete(res.id)
-    # p res
-    puts "shouldn't be any more"
-    res = queue.get
+    res = queue.delete(res.id, res.reservation_id)
+
+    res = queue.reserve
     # p res
     assert_nil res
 
@@ -110,14 +77,13 @@ class IronMQTests < TestBase
     # p res
     assert res.msg
 
-    res = queue.get
+    res = queue.reserve
     # p res
     assert res.body
 
     res = res.delete
     # p res
-    puts "shouldn't be any more"
-    res = queue.get
+    res = queue.reserve
     # p res
     assert_nil res
 
@@ -126,7 +92,10 @@ class IronMQTests < TestBase
     assert_equal 200, resp.code, "API must response with HTTP 200 status, but returned HTTP #{resp.code}"
   end
 
+
+
   def test_multi_delete
+    puts 'test_multi_delete'
     queue_name = 'test_multi_delete_41'
     clear_queue(queue_name)
 
@@ -134,7 +103,7 @@ class IronMQTests < TestBase
     ids = []
     10.times do |i|
       msg = queue.post("hello #{i}")
-      ids << msg.id
+      ids << {id: msg.id}
     end
     sleep 0.5
     assert_equal 10, queue.reload.size
@@ -142,10 +111,42 @@ class IronMQTests < TestBase
     queue.delete_messages(ids)
     sleep 1
     assert_equal 0, queue.reload.size
+
+    # now try it with reserved messages
+    ids = []
+    10.times do |i|
+      msg = queue.post("hello #{i}")
+    end
+    sleep 0.5
+    assert_equal 10, queue.reload.size
+    while (msg = queue.reserve) != nil do
+      ids << {id: msg.id, reservation_id: msg.reservation_id}
+    end
+    queue.delete_messages(ids)
+    sleep 1
+    assert_equal 0, queue.reload.size
+
     queue.delete_queue
 
   end
 
+  def test_reservation_ids
+    puts 'test_reservation_ids'
+    # get a message, let it timeout, then try to delete it. That should fail.
+    queue_name = 'test_res_ids'
+    clear_queue(queue_name)
+
+    queue = @client.queue(queue_name)
+    msg = queue.post("hello")
+    msg = queue.reserve(:timeout=>3)
+    sleep 3
+    ex = assert_raises Rest::HttpError do
+      msg.delete
+    end
+    assert_equal 403, ex.code
+
+  end
+
   def test_queues_list
     queue_name = 'test_queues_list_1'
     clear_queue(queue_name)
@@ -190,42 +191,43 @@ class IronMQTests < TestBase
 
     sleep 61 # should be 1 minute timeout by default
     new_msg = queue.get
-    assert_not_nil new_msg
+    refute_nil new_msg
     assert_equal new_msg.id, msg.id
     new_msg.delete
 
     # now try explicit timeout
-    res = queue.post("hello world timeout2!", :timeout => 30)
-    # p res
-    msg = queue.get
+    timeout = 5
+    res = queue.post("hello world timeout2!", :timeout => timeout)
+    # p resds
+    msg = queue.get(:timeout=>timeout)
     # p msg
     assert msg
-    assert_equal 30, msg.timeout
+    # assert_equal 30, msg.timeout - removed in v3
 
-    msg_nil = queue.get
+    msg_nil = queue.get(:timeout=>timeout)
     # p msg_nil
     assert_nil msg_nil
 
-    sleep 31
-    new_msg = queue.get
-    assert_not_nil new_msg
+    sleep timeout + 1
+    new_msg = queue.get(:timeout=>timeout)
+    refute_nil new_msg
     assert_equal new_msg.id, msg.id
     new_msg.delete
 
     # timeout on get
     res = queue.post("hello world timeout3!")
-    msg = queue.get(:timeout => 30)
-#    puts "MESSAGE IS #{msg.inspect}"
+    msg = queue.get(:timeout => timeout)
+    #    puts "MESSAGE IS #{msg.inspect}"
     assert msg
-    assert_equal msg.timeout, 30
+    # assert_equal msg.timeout, 30 - removed in v3
 
-    msg_nil = queue.get
+    msg_nil = queue.get(:timeout=>timeout)
     # p msg_nil
     assert_nil msg_nil
 
-    sleep 31
+    sleep timeout+1
     new_msg = queue.get
-    assert_not_nil new_msg
+    refute_nil new_msg
     assert_equal new_msg.id, msg.id
     new_msg.delete
 
@@ -234,39 +236,21 @@ class IronMQTests < TestBase
     assert_equal 200, resp.code, "API must response with HTTP 200 status, but returned HTTP #{resp.code}"
   end
 
+  # todo: This test should be changed to make queues, it assumes 30+ queues are already created.
   def test_queues
-    puts 'test_queues'
+    puts "test_queues-#{Time.now.to_i}"
 
     qname = "some_queue_that_does_not_exist_1"
     queue = @client.queue(qname)
-    # delete it before the test
-    queue.delete_queue
-
-    assert_raise Rest::HttpError do
-      # should raise a 404
-      m = queue.size
-    end
-
     # create at least one queue
     queue.post('create queue message')
     # queue should exist now
     m = queue.get
-    assert_not_nil m
+    refute_nil m
 
-    res = @client.queues.list
+    res = @client.queues.list(page: 1, per_page: 30)
     # puts "res.size: #{res.size}"
-    res.each do |q|
-      # puts "queue_name: " + q.name
-      # puts "queue size: " + q.size.to_s
-      assert q.size >= 0
-    end
-    assert res.size > 0
-
-    res = @client.queues.list(:page => 50)
-    # puts "res.size 2: #{res.size}"
-    # res.each do |q| { p q.name }
-
-    assert_equal 0, res.size
+    assert_equal 30, res.size
 
     # delete queue on test complete
     resp = queue.delete_queue
@@ -289,7 +273,7 @@ class IronMQTests < TestBase
 
     sleep 6
     new_msg = queue.get
-    assert_not_nil new_msg
+    refute_nil new_msg
     assert_equal msg_id, new_msg.id
     new_msg.delete
 
@@ -327,7 +311,7 @@ class IronMQTests < TestBase
     assert msgs.is_a?(Array)
     msgs.each do |m|
       puts m.id
-      assert_not_equal msg.id, m.id
+      refute_equal msg.id, m.id
     end
     assert msgs.size == 9, "size should be 9, but it's #{msgs.size}"
     assert msgs[0]["id"]
@@ -363,11 +347,11 @@ class IronMQTests < TestBase
     queue.post("third message")
 
     msg = queue.peek
-    assert_not_nil msg
+    refute_nil msg
     assert_equal "first message", msg.body, "message body must be 'first message', but it's '#{msg.body}'"
 
     msg = queue.peek
-    assert_not_nil msg
+    refute_nil msg
     assert_equal "first message", msg.body, "message body must be 'first message', but it's '#{msg.body}'"
 
     msgs = queue.peek(:n => 2)
@@ -375,7 +359,7 @@ class IronMQTests < TestBase
     assert_equal 2, msgs.size, "must received 2 messages, but received #{msgs.size}"
 
     msg = queue.peek
-    assert_not_nil msg
+    refute_nil msg
     assert_equal "first message", msg.body, "message body must be 'first message', but it's '#{msg.body}'"
 
     msgs = queue.peek(:n => 7)
@@ -383,14 +367,14 @@ class IronMQTests < TestBase
     assert_equal 3, msgs.size, "must received 3 messages, but received #{msgs.size}"
 
     msg = queue.get
-    assert_not_nil msg
+    refute_nil msg
     assert_equal "first message", msg.body, "message body must be 'first message', but it's '#{msg.body}'"
 
     resp = msg.delete
     assert_equal 200, resp.code, "API must response with HTTP 200 status, but returned HTTP #{resp.code}"
 
     msg = queue.peek
-    assert_not_nil msg
+    refute_nil msg
     assert_equal "second message", msg.body, "message body must be 'second message', but it's '#{msg.body}'"
 
     # delete queue on test complete
@@ -405,60 +389,65 @@ class IronMQTests < TestBase
     clear_queue(queue_name)
 
     queue = @client.queue(queue_name)
-    queue.post("first message", :timeout => 30)
-    queue.post("second message", :timeout => 30)
-    queue.post("third message", :timeout => 30)
+    queue.post("first message")
+    queue.post("second message")
+    queue.post("third message")
 
 
     # get message
-    msg = queue.get
-    assert_not_nil msg
+    msg = queue.get(:timeout => 10)
+    refute_nil msg
     assert_equal "first message", msg.body, "message body must be 'first message', but it's '#{msg.body}'"
 
-    sleep 15 # timeout is not passed
+    sleep 5 # timeout is not passed
 
     msgs = queue.peek(:n => 3) # all messages from queue
     assert_equal Array, msgs.class, "waiting for Array, but got #{msgs.class}"
     assert_equal 2, msgs.size, "API must return only 2 messages"
     msgs.each do |m|
-      assert_not_equal msg.id, m.id, "returned a message which must be reserved"
+      refute_equal msg.id, m.id, "returned a message which must be reserved"
     end
 
-    sleep 20 # ensure timeout is passed
+    sleep 5.5 # ensure timeout is passed
 
     # message must return to the queue
     msgs = queue.peek(:n => 3)
     assert_equal Array, msgs.class, "waiting for Array, but got #{msgs.class}"
     assert_equal 3, msgs.size, "API must return 3 messages"
 
-    msg = queue.get
-    assert_not_nil msg
+    msg = queue.get(:timeout=>10)
+    refute_nil msg
     assert_equal "second message", msg.body, "message body must be 'second message', but it's '#{msg.body}'"
 
-    sleep 15 # timeout is not passed
+    sleep 5 # timeout is not passed
 
     msgs = queue.peek(:n => 3) # must return another message
     assert_equal Array, msgs.class, "waiting for Array, but got #{msgs.class}"
     assert_equal 2, msgs.size, "API must return only 2 messages"
-    msgs.each { |m| assert_not_equal msg.id, m.id, "returned message which must be reserved" }
+    msgs.each { |m| refute_equal msg.id, m.id, "returned message which must be reserved" }
 
-    resp = msg.touch # more 30 seconds timeout
+    resp = msg.touch # (:timeout=>10) # increase timeout again, should be another 10 seconds
     assert_equal 200, resp.code, "API must response with HTTP 200 status, but returned HTTP #{resp.code}"
 
-    sleep 20 # new timeout is not passed, but previous is (15 + 20 vs 30 + 30 seconds)
+    sleep 5 # new timeout is not passed, but previous is (15 + 20 vs 30 + 30 seconds)
 
     msgs = queue.peek(:n => 3) # must return the same as for msg2
     assert_equal Array, msgs.class, "waiting for Array, but got #{msgs.class}"
     assert_equal 2, msgs.size, "API must return only 2 messages"
-    msgs.each { |m| assert_not_equal msg.id, m.id, "returned message which must be reserved" }
+    msgs.each { |m| refute_equal msg.id, m.id, "returned message which must be reserved" }
 
-    sleep 15 # ensure timeout passed
+    sleep 5 # ensure timeout passed
+    queue.clear
+    queue.post("first message")
+    queue.post("second message")
+    queue.post("third message")
 
     # message must be returned to the end of the queue
     msgs = queue.peek(:n => 3)
+    msg = queue.reserve
     assert_equal Array, msgs.class, "waiting for Array, but got #{msgs.class}"
     assert_equal 3, msgs.size, "API must return 3 messages"
-    assert_equal msg.id, msgs[2].id, "released message must be at the end of the queue"
+    assert_equal msg.id, msgs[0].id, "released message must be at the beginning of the queue"
 
     # delete queue on test complete
     resp = queue.delete_queue
@@ -468,57 +457,52 @@ class IronMQTests < TestBase
   def test_release
     puts 'test_release'
 
-    queue_name = "test_release_6"
+    queue_name = "test_release_#{Time.now.to_i}"
     clear_queue(queue_name)
 
-    msg_txt = "testMessage-"+Time.now.to_s
+    msg_txt = "testMessage-#{Time.now.to_i}"
     # puts msgTxt
 
     queue = @client.queue(queue_name)
 
     msg_id = queue.post(msg_txt, {:timeout => 60*5}).id
     # puts "msg_id: #{msg_id}"
-    message = queue.get
+    message = queue.reserve
     # p msg
     assert_equal msg_id, message.id
     # Ok, so should have received same message, now let's release it quicker than the original timeout
 
     # but first, ensure the next get is nil
-    msg = queue.get
+    msg = queue.reserve
     # p msg
     assert_nil msg
 
     # now release it instantly
-    message.release
-    msg = queue.get
-    # p msg
-    assert msg
-    assert_equal msg_id, msg.id
+    re = message.release
+    msg = queue.reserve
 
-    # ok, so should be reserved again
-    msgr = queue.get
-    # p msgr
-    assert_nil msgr
+    assert msg.raw
+    assert_equal msg_id, msg.id
 
     # let's release it in 10 seconds
     msg.release(:delay => 10)
-    msgr = queue.get
+    msgr = queue.reserve
     # p msg
     assert_nil msgr
 
     sleep 11
-    msg = queue.get
-    assert_not_nil msg
+    msg = queue.reserve
+    refute_nil msg
     assert_equal msg_id, msg.id
 
     msg.release(:delay => 5)
-    msg = queue.get
+    msg = queue.reserve
     # p msg
     assert_nil msg
 
     sleep 6
-    msg = queue.get
-    assert_not_nil msg
+    msg = queue.reserve
+    refute_nil msg
     assert_equal msg_id, msg.id
 
     # delete queue on test complete
@@ -526,7 +510,6 @@ class IronMQTests < TestBase
     assert_equal 200, resp.code, "API must response with HTTP 200 status, but returned HTTP #{resp.code}"
   end
 
-
   def test_clear
     puts "test_clear"
 
@@ -579,7 +562,6 @@ class IronMQTests < TestBase
   def test_queue_delete
     queue = @client.queue("test_delete")
     queue.post("hi")
-    old_id = queue.id
     queue.delete_queue
 
     LOG.info "sleeping for a bit to let queue delete..."
@@ -587,7 +569,6 @@ class IronMQTests < TestBase
 
     queue.post("hi2")
     # p queue
-    assert_not_equal old_id, queue.id, "old queue ID (#{old_id}) must not be equal to new ID (#{queue.id})"
     assert_equal 1, queue.size, "queue size must be 1, but got #{queue.size}"
 
     msg = queue.get
@@ -600,7 +581,7 @@ class IronMQTests < TestBase
 
   def test_webhooks
     qname ="webhook_queue"
-    url = "#{@client.base_url}/#{qname}/messages/webhook?oauth=#{@client.token}"
+    url = "#{@client.base_url}/#{qname}/webhook?oauth=#{@client.token}"
     # p url
 
     v = "hello webhook"
@@ -666,13 +647,13 @@ class IronMQTests < TestBase
   end
 
   def test_queue_set_info
-    qname = "test_queue_set_info"
+    qname = "test_queue_set_info_#{Time.now.to_i}"
     clear_queue(qname)
     q = @client.queue(qname)
-    q.update_queue(:push_type => 'unicast')
-    assert_equal 'unicast', q.push_type
-    q.update_queue(:retries => 10)
-    assert_equal 'unicast', q.reload.push_type
+    q.update(message_timeout: 45)
+    assert_equal 45, q.reload.info['message_timeout']
+    q.update(message_expiration: 3000)
+    assert_equal 3000, q.reload.info['message_expiration']
   end
 
   def test_dequeue_delete
@@ -681,7 +662,7 @@ class IronMQTests < TestBase
     queue = @client.queue(queue_name)
     v = "hello thou shalt only see me once"
     queue.post(v)
-    msg = queue.get(delete: 1, timeout: 30)
+    msg = queue.get(delete: true, timeout: 30)
     assert_equal msg.body, "hello thou shalt only see me once"
     sleep 1
     # get the queue again
@@ -691,5 +672,66 @@ class IronMQTests < TestBase
     msg = queue.get
     assert_equal nil, msg
   end
+
+  def test_long_polling
+    queue_name = "test_long_polling#{Time.now.to_i}"
+    queue = @client.queue(queue_name)
+    queue.update
+    msg = queue.get
+    assert_nil msg
+    v = "hello long"
+    # ok, nothing in the queue, let's do a long poll
+    starti = Time.now.to_i
+    thr = Thread.new {
+      sleep 5
+      puts "Posting now"
+      begin
+        queue.post(v)
+      rescue Exception => ex
+        p ex
+      end
+
+    }
+    puts "Now going to wait for it..."
+    msg = queue.get(wait: 20)
+    # p msg
+    endi = Time.now.to_i
+    duration = endi - starti
+    p duration
+    assert duration > 4 && duration <= 7
+    refute_nil msg
+    assert_equal v, msg.body
+    msg.delete
+  end
+
+  def test_delete_reserved_messages
+    queue_name = 'test_delete_reserved_messages'
+    queue = @client.queue(queue_name)
+    clear_queue(queue_name)
+    queue.post("more")
+    queue.post("and more")
+    queue.post("and more")
+    assert_equal 3, queue.size
+    messages = queue.reserve(n: 3)
+    queue.delete_reserved_messages(messages)
+    assert_equal 0, queue.reload.size
+  end
+
+  def test_delete_reserved_message
+    queue_name = 'test_delete_message'
+    queue = @client.queue(queue_name)
+    clear_queue(queue_name)
+    queue.post("test message")
+    assert_equal 1, queue.reload.size
+    message = queue.reserve
+    queue.delete(message.id, message.reservation_id)
+    assert_equal 0, queue.reload.size
+
+    queue.post("another message")
+    assert_equal 1, queue.reload.size
+    message = queue.reserve
+    message.delete
+    assert_equal 0, queue.reload.size
+  end
 end