resque-bus 0.3.2 → 0.7.0

data/spec/adapter/integration_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe "Resque Integration" do
+  describe "Happy Path" do
+    before(:each) do
+      QueueBus.dispatch("r1") do
+        subscribe "event_name" do |attributes|
+          QueueBus::Runner1.run(attributes)
+        end
+      end
+
+      QueueBus::TaskManager.new(false).subscribe!
+
+      @incoming = Resque::Worker.new(:bus_incoming)
+      @incoming.register_worker
+
+      @rider = Resque::Worker.new(:r1_default)
+      @rider.register_worker
+    end
+
+    it "should publish and receive" do
+      QueueBus::Runner1.value.should == 0
+
+      QueueBus.publish("event_name", "ok" => true)
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @incoming
+
+      QueueBus::Runner1.value.should == 0
+
+      perform_next_job @rider
+
+      QueueBus::Runner1.value.should == 1
+    end
+  end
+
+  describe "Delayed Publishing" do
+    before(:each) do
+      Timecop.freeze(now)
+      QueueBus.stub(:generate_uuid).and_return("idfhlkj")
+    end
+    after(:each) do
+      Timecop.return
+    end
+    let(:delayed_attrs) { {"bus_delayed_until" => future.to_i,
+                       "bus_id" => "#{now.to_i}-idfhlkj",
+                       "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
+
+    let(:bus_attrs) { delayed_attrs.merge({"bus_published_at" => worktime.to_i})}
+    let(:now)    { Time.parse("01/01/2013 5:00")}
+    let(:future) { Time.at(now.to_i + 60) }
+    let(:worktime) {Time.at(future.to_i + 1)}
+
+    it "should add it to Redis" do
+      hash = {:one => 1, "two" => "here", "id" => 12 }
+      event_name = "event_name"
+      QueueBus.publish_at(future, event_name, hash)
+
+      schedule = QueueBus.redis { |redis| redis.zrange("delayed_queue_schedule", 0, 1) }
+      schedule.should == [future.to_i.to_s]
+
+      val = QueueBus.redis { |redis| redis.lpop("delayed:#{future.to_i}") }
+      hash = JSON.parse(val)
+
+      hash["class"].should == "QueueBus::Worker"
+      hash["args"].size.should == 1
+      JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs)
+      hash["queue"].should == "bus_incoming"
+    end
+
+    it "should move it to the real queue when processing" do
+      hash = {:one => 1, "two" => "here", "id" => 12 }
+      event_name = "event_name"
+
+      val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+      val.should == nil
+
+      QueueBus.publish_at(future, event_name, hash)
+
+      val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+      val.should == nil # nothing really added
+
+      # process sceduler now
+      Resque::Scheduler.handle_delayed_items
+
+      val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+      val.should == nil # nothing added yet
+
+      # process scheduler in future
+      Timecop.freeze(worktime) do
+        Resque::Scheduler.handle_delayed_items
+
+        # added
+        val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+        hash = JSON.parse(val)
+        hash["class"].should == "QueueBus::Worker"
+        hash["args"].size.should == 1
+        JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs)
+
+       QueueBus::Publisher.perform(JSON.parse(hash["args"].first))
+
+       val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+       hash = JSON.parse(val)
+       hash["class"].should == "QueueBus::Worker"
+       hash["args"].size.should == 1
+       JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Driver", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs)
+      end
+    end
+
+  end
+end

data/spec/adapter/publish_at_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe "Publishing an event in the future" do
+
+  before(:each) do
+    Timecop.freeze(now)
+    QueueBus.stub(:generate_uuid).and_return("idfhlkj")
+  end
+  after(:each) do
+    Timecop.return
+  end
+  let(:delayed_attrs) { {"bus_delayed_until" => future.to_i,
+                     "bus_id" => "#{now.to_i}-idfhlkj",
+                     "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
+
+  let(:bus_attrs) { delayed_attrs.merge({"bus_published_at" => worktime.to_i})}
+  let(:now)    { Time.parse("01/01/2013 5:00")}
+  let(:future) { Time.at(now.to_i + 60) }
+  let(:worktime) {Time.at(future.to_i + 1)}
+
+  it "should add it to Redis then to the real queue" do
+    hash = {:one => 1, "two" => "here", "id" => 12 }
+    event_name = "event_name"
+    QueueBus.publish_at(future, event_name, hash)
+
+    schedule = QueueBus.redis { |redis| redis.zrange("delayed_queue_schedule", 0, 1) }
+    schedule.should == [future.to_i.to_s]
+
+    val = QueueBus.redis { |redis| redis.lpop("delayed:#{future.to_i}") }
+    hash = JSON.parse(val)
+
+    hash["class"].should == "QueueBus::Worker"
+    hash["args"].size.should == 1
+    JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs)
+    hash["queue"].should == "bus_incoming"
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val.should == nil # nothing really added
+
+    Timecop.freeze(worktime)
+    QueueBus::Publisher.perform(JSON.parse(hash["args"].first))
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    hash = JSON.parse(val)
+    hash["class"].should == "QueueBus::Worker"
+    hash["args"].size.should == 1
+    JSON.parse(hash["args"].first).should == {"bus_class_proxy" => "QueueBus::Driver", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs)
+  end
+
+end

data/spec/adapter/retry_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe "Retry" do
+  class RetryTest1
+    include QueueBus::Subscriber
+    application :my_thing
+    subscribe :event_sub
+    def event_sub(attributes)
+      QueueBus::Runner1.run(attributes)
+    end
+  end
+
+  it "should have the methods" do
+    ::QueueBus::Worker.methods.should include(:on_failure_aaa)
+    ::QueueBus::Worker.methods.should include(:on_failure_zzz)
+  end
+
+  # it "should retry failed riders"
+
+  describe "Failed Jobs" do
+    before(:each) do
+      QueueBus.enqueue_to("testing", "QueueBus::Worker", { "bus_class_proxy" => "QueueBus::Rider", "bus_rider_app_key" => "r2", "bus_rider_sub_key" => "event_name", "bus_event_type" => "event_name", "ok" => true, "bus_rider_queue" => "testing" })
+
+      @worker = Resque::Worker.new(:testing)
+      @worker.register_worker
+    end
+
+    it "should put it in the failed jobs" do
+
+      QueueBus.dispatch("r2") do
+        subscribe "event_name" do |attributes|
+          raise "boo!"
+        end
+      end
+
+      perform_next_job @worker
+      Resque.info[:processed].should == 1
+      Resque.info[:failed].should == 1
+      Resque.info[:pending].should == 1 # requeued
+
+      perform_next_job @worker
+      Resque.info[:processed].should == 2
+      Resque.info[:failed].should == 2
+      Resque.info[:pending].should == 0
+    end
+  end
+end

data/spec/adapter/support.rb

@@ -0,0 +1,23 @@
+require 'resque-bus'
+require 'resque'
+require 'resque/scheduler'
+
+def reset_test_adapter
+  QueueBus.send(:reset)
+  QueueBus.adapter = QueueBus::Adapters::Resque.new
+end
+
+def adapter_under_test_class
+  QueueBus::Adapters::Resque
+end
+
+def adapter_under_test_symbol
+  :resque
+end
+
+def perform_next_job(worker, &block)
+  return unless job = worker.reserve
+  worker.perform(job, &block)
+  worker.done_working
+end
+

data/spec/adapter_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "adapter is set" do
+  it "should call it's enabled! method on init" do
+    QueueBus.send(:reset)
+    adapter_under_test_class.any_instance.should_receive(:enabled!)
+    instance = adapter_under_test_class.new
+    QueueBus.send(:reset)
+  end
+
+  it "should be defaulting to Data from spec_helper" do
+    QueueBus.adapter.is_a?(adapter_under_test_class).should == true
+  end
+end

data/spec/application_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-module ResqueBus
+module QueueBus
   describe Application do
     describe ".all" do
       it "should return empty array when none" do
@@ -10,143 +10,143 @@ module ResqueBus
         Application.new("One").subscribe(test_list(test_sub("fdksjh")))
         Application.new("Two").subscribe(test_list(test_sub("fdklhf")))
         Application.new("Three").subscribe(test_list(test_sub("fkld")))
-        
+
         Application.all.collect(&:app_key).should =~ ["one", "two", "three"]
-        
+
         Application.new("two").unsubscribe
         Application.all.collect(&:app_key).should =~ ["one", "three"]
       end
     end
-    
+
     describe ".new" do
       it "should have a key" do
         Application.new("something").app_key.should == "something"
-      
+
         Application.new("some thing").app_key.should == "some_thing"
         Application.new("some-thing").app_key.should == "some_thing"
         Application.new("some_thing").app_key.should == "some_thing"
         Application.new("Some Thing").app_key.should == "some_thing"
       end
-    
+
       it "should raise an error if not valid" do
         lambda {
           Application.new("")
         }.should raise_error
-      
+
         lambda {
           Application.new(nil)
         }.should raise_error
-      
+
         lambda {
           Application.new("/")
         }.should raise_error
       end
     end
-    
+
     describe "#read_redis_hash" do
       it "should handle old and new values" do
-        
-        ResqueBus.redis.hset("resquebus_app:myapp", "new_one", Resque.encode("queue_name" => "x", "bus_event_type" => "event_name"))
-        ResqueBus.redis.hset("resquebus_app:myapp", "old_one", "oldqueue_name")
+
+        QueueBus.redis { |redis| redis.hset("bus_app:myapp", "new_one", QueueBus::Util.encode("queue_name" => "x", "bus_event_type" => "event_name") ) }
+        QueueBus.redis { |redis| redis.hset("bus_app:myapp", "old_one", "oldqueue_name") }
         app = Application.new("myapp")
         val = app.send(:read_redis_hash)
         val.should == {"new_one" => {"queue_name" => "x", "bus_event_type" => "event_name"}, "old_one" => "oldqueue_name"}
       end
     end
-  
+
     describe "#subscribe" do
       let(:sub1) { test_sub("event_one", "default") }
       let(:sub2) { test_sub("event_two", "default") }
       let(:sub3) { test_sub("event_three", "other") }
       it "should add array to redis" do
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
         Application.new("myapp").subscribe(test_list(sub1, sub2))
-      
-        ResqueBus.redis.hgetall("resquebus_app:myapp").should == {"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::ResqueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}", 
-                                                                  "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::ResqueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"}
-        ResqueBus.redis.hkeys("resquebus_app:myapp").should =~ ["event_one", "event_two"]
-        ResqueBus.redis.smembers("resquebus_apps").should =~ ["myapp"]
+
+        QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }.should == {"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}",
+                                                                  "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"}
+        QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }.should =~ ["event_one", "event_two"]
+        QueueBus.redis { |redis| redis.smembers("bus_apps") }.should =~ ["myapp"]
       end
       it "should add string to redis" do
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
         Application.new("myapp").subscribe(test_list(sub1))
-      
-        ResqueBus.redis.hgetall("resquebus_app:myapp").should == {"event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::ResqueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"}
-        ResqueBus.redis.hkeys("resquebus_app:myapp").should =~ ["event_one"]
-        ResqueBus.redis.smembers("resquebus_apps").should =~ ["myapp"]
+
+        QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }.should == {"event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"}
+        QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }.should =~ ["event_one"]
+        QueueBus.redis { |redis| redis.smembers("bus_apps") }.should =~ ["myapp"]
       end
       it "should multiple queues to redis" do
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
         Application.new("myapp").subscribe(test_list(sub1, sub2, sub3))
-        ResqueBus.redis.hgetall("resquebus_app:myapp").should == {"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::ResqueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}", "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::ResqueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}", 
-                                                                  "event_three"=>"{\"queue_name\":\"other\",\"key\":\"event_three\",\"class\":\"::ResqueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_three\"}}"}
-        ResqueBus.redis.hkeys("resquebus_app:myapp").should =~ ["event_three", "event_two", "event_one"]
-        ResqueBus.redis.smembers("resquebus_apps").should =~ ["myapp"]
+        QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }.should == {"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}", "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}",
+                                                                  "event_three"=>"{\"queue_name\":\"other\",\"key\":\"event_three\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_three\"}}"}
+        QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }.should =~ ["event_three", "event_two", "event_one"]
+        QueueBus.redis { |redis| redis.smembers("bus_apps") }.should =~ ["myapp"]
       end
-    
+
       it "should do nothing if nil or empty" do
-      
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
-      
+
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+
         Application.new("myapp").subscribe(nil)
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
-      
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
+
         Application.new("myapp").subscribe([])
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
       end
-      
+
       it "should call unsubscribe" do
         app = Application.new("myapp")
         app.should_receive(:unsubscribe)
         app.subscribe([])
       end
     end
-  
+
     describe "#unsubscribe" do
       it "should remove items" do
-        ResqueBus.redis.sadd("resquebus_apps", "myapp")
-        ResqueBus.redis.sadd("resquebus_apps", "other")
-        ResqueBus.redis.hset("resquebus_app:myapp", "event_one", "myapp_default")
-      
+        QueueBus.redis { |redis| redis.sadd("bus_apps", "myapp") }
+        QueueBus.redis { |redis| redis.sadd("bus_apps", "other") }
+        QueueBus.redis { |redis| redis.hset("bus_app:myapp", "event_one", "myapp_default") }
+
         Application.new("myapp").unsubscribe
-      
-        ResqueBus.redis.smembers("resquebus_apps").should == ["other"]
-        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
+
+        QueueBus.redis { |redis| redis.smembers("bus_apps") }.should == ["other"]
+        QueueBus.redis { |redis| redis.get("bus_app:myapp") }.should be_nil
       end
     end
-    
+
     describe "#subscription_matches" do
       it "should return if it is there" do
         Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
-        
+
         subs = test_list(test_sub("one_x"), test_sub("one_y"), test_sub("one"), test_sub("two"))
         Application.new("myapp").subscribe(subs)
         Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
-        
-        Application.new("myapp").subscription_matches("bus_event_type"=>"two").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "two", "default", "::ResqueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one", "default", "::ResqueBus::Rider"]]
+
+        Application.new("myapp").subscription_matches("bus_event_type"=>"two").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "two", "default", "::QueueBus::Rider"]]
+        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one", "default", "::QueueBus::Rider"]]
       end
-      
+
       it "should handle * wildcards" do
         subs = test_list(test_sub("one.+"), test_sub("one"), test_sub("one_.*"), test_sub("two"))
         Application.new("myapp").subscribe(subs)
         Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
-        
-        Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one.+", "default", "::ResqueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one", "default", "::ResqueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one.+","default", "::ResqueBus::Rider"], ["myapp", "one_.*", "default", "::ResqueBus::Rider"]]
+
+        Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one.+", "default", "::QueueBus::Rider"]]
+        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one", "default", "::QueueBus::Rider"]]
+        Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one.+","default", "::QueueBus::Rider"], ["myapp", "one_.*", "default", "::QueueBus::Rider"]]
       end
-      
+
       it "should handle actual regular expressions" do
         subs = test_list(test_sub(/one.+/), test_sub("one"), test_sub(/one_.*/), test_sub("two"))
         Application.new("myapp").subscribe(subs)
         Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
-        
-        Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::ResqueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"donex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::ResqueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one" ,"default", "::ResqueBus::Rider"]]
-        Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::ResqueBus::Rider"], ["myapp", "(?-mix:one_.*)", "default", "::ResqueBus::Rider"]]
+
+        Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"]]
+        Application.new("myapp").subscription_matches("bus_event_type"=>"donex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"]]
+        Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "one" ,"default", "::QueueBus::Rider"]]
+        Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"], ["myapp", "(?-mix:one_.*)", "default", "::QueueBus::Rider"]]
       end
     end
   end
-end
+end