queue-bus 0.5.0

data/spec/driver_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+module QueueBus
+  describe Driver do
+    before(:each) do
+      Application.new("app1").subscribe(test_list(test_sub("event1"), test_sub("event2"), test_sub("event3")))
+      Application.new("app2").subscribe(test_list(test_sub("event2","other"), test_sub("event4", "more")))
+      Application.new("app3").subscribe(test_list(test_sub("event[45]"), test_sub("event5"), test_sub("event6")))
+      Timecop.freeze
+    end
+    after(:each) do
+      Timecop.return
+    end
+
+    let(:bus_attrs) { {"bus_driven_at" => Time.now.to_i, "bus_rider_class_name"=>"::QueueBus::Rider"} }
+
+    describe ".subscription_matches" do
+      it "return empty array when none" do
+        Driver.subscription_matches("bus_event_type" => "else").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
+        Driver.subscription_matches("bus_event_type" => "event").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should == []
+      end
+      it "should return a match" do
+        Driver.subscription_matches("bus_event_type" => "event1").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app1", "event1", "default", "::QueueBus::Rider"]]
+        Driver.subscription_matches("bus_event_type" => "event6").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app3", "event6", "default", "::QueueBus::Rider"]]
+      end
+      it "should match multiple apps" do
+        Driver.subscription_matches("bus_event_type" => "event2").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app1", "event2", "default", "::QueueBus::Rider"], ["app2", "event2", "other", "::QueueBus::Rider"]]
+      end
+      it "should match multiple apps with patterns" do
+        Driver.subscription_matches("bus_event_type" => "event4").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app3", "event[45]", "default", "::QueueBus::Rider"], ["app2", "event4", "more", "::QueueBus::Rider"]]
+      end
+      it "should match multiple events in same app" do
+        Driver.subscription_matches("bus_event_type" => "event5").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}.should =~ [["app3", "event[45]", "default", "::QueueBus::Rider"], ["app3", "event5", "default", "::QueueBus::Rider"]]
+      end
+    end
+
+    describe ".perform" do
+      let(:attributes) { {"x" => "y"} }
+
+      before(:each) do
+        QueueBus.redis { |redis| redis.smembers("queues") }.should == []
+        QueueBus.redis { |redis| redis.lpop("queue:app1_default") }.should be_nil
+        QueueBus.redis { |redis| redis.lpop("queue:app2_default") }.should be_nil
+        QueueBus.redis { |redis| redis.lpop("queue:app3_default") }.should be_nil
+      end
+
+      it "should do nothing when empty" do
+        Driver.perform(attributes.merge("bus_event_type" => "else"))
+        QueueBus.redis { |redis| redis.smembers("queues") }.should == []
+      end
+
+      it "should queue up the riders in redis" do
+        QueueBus.redis { |redis| redis.lpop("queue:app1_default") }.should be_nil
+        Driver.perform(attributes.merge("bus_event_type" => "event1"))
+        QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["default"]
+
+        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
+        hash["class"].should == "::QueueBus::Rider"
+        hash["args"].should == [ {"bus_rider_app_key"=>"app1", "x" => "y", "bus_event_type" => "event1", "bus_rider_sub_key"=>"event1", "bus_rider_queue" => "default"}.merge(bus_attrs) ]
+      end
+
+      it "should queue up to multiple" do
+        Driver.perform(attributes.merge("bus_event_type" => "event4"))
+        QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["default", "more"]
+
+        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:more") })
+        hash["class"].should == "::QueueBus::Rider"
+        hash["args"].should == [ {"bus_rider_app_key"=>"app2", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event4", "bus_rider_queue" => "more"}.merge(bus_attrs) ]
+
+        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
+        hash["class"].should == "::QueueBus::Rider"
+        hash["args"].should == [ {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs) ]
+      end
+
+      it "should queue up to the same" do
+        Driver.perform(attributes.merge("bus_event_type" => "event5"))
+        QueueBus.redis { |redis| redis.smembers("queues") }.should =~ ["default"]
+
+        QueueBus.redis { |redis| redis.llen("queue:default") }.should == 2
+
+        pop1 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
+        pop2 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
+
+        if pop1["args"][0]["bus_rider_sub_key"] == "event5"
+          hash1 = pop1
+          hash2 = pop2
+        else
+          hash1 = pop2
+          hash2 = pop1
+        end
+
+        hash1["class"].should == "::QueueBus::Rider"
+        hash1["args"][0].should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event5", "bus_rider_queue" => "default"}.merge(bus_attrs)
+
+        hash2["class"].should == "::QueueBus::Rider"
+        hash2["args"][0].should == {"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs)
+      end
+    end
+  end
+end

data/spec/heartbeat_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module QueueBus
+  describe Heartbeat do
+    def now_attributes
+      {
+        "epoch_seconds" => (Time.now.to_i / 60) * 60, # rounded
+        "epoch_minutes" => Time.now.to_i / 60,
+        "epoch_hours"   => Time.now.to_i / (60*60),
+        "epoch_days"    => Time.now.to_i / (60*60*24),
+        "minute" => Time.now.min,
+        "hour"   => Time.now.hour,
+        "day"    => Time.now.day,
+        "month"  => Time.now.month,
+        "year"   => Time.now.year,
+        "yday"   => Time.now.yday,
+        "wday"   => Time.now.wday
+      }
+    end
+    
+    it "should publish the current time once" do
+      Timecop.freeze "12/12/2013 12:01:19" do
+        QueueBus.should_receive(:publish).with("heartbeat_minutes", now_attributes)
+        Heartbeat.perform
+      end
+      
+      Timecop.freeze "12/12/2013 12:01:40" do
+        Heartbeat.perform
+      end
+    end
+    
+    it "should publish a minute later" do
+      Timecop.freeze "12/12/2013 12:01:19" do
+        QueueBus.should_receive(:publish).with("heartbeat_minutes", now_attributes)
+        Heartbeat.perform
+      end
+      
+      Timecop.freeze "12/12/2013 12:02:01" do
+        QueueBus.should_receive(:publish).with("heartbeat_minutes", now_attributes)
+        Heartbeat.perform
+      end
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module QueueBus
+  describe "Integration" do
+    it "should round trip attributes" do      
+      write1 = Subscription.new("default", "key1", "MyClass1", {"bus_event_type" => "event_one"})
+      write2 = Subscription.new("else_ok", "key2", "MyClass2", {"bus_event_type" => /^[ab]here/})  #regex
+    
+      write1.matches?("bus_event_type" => "event_one").should  == true
+      write1.matches?("bus_event_type" => "event_one1").should == false
+      write1.matches?("bus_event_type" => "aevent_one").should == false
+      
+      write2.matches?("bus_event_type" => "ahere").should == true
+      write2.matches?("bus_event_type" => "bhere").should == true
+      write2.matches?("bus_event_type" => "qhere").should == false
+      write2.matches?("bus_event_type" => "abhere").should == false
+      write2.matches?("bus_event_type" => "[ab]here").should == false
+    
+      write = SubscriptionList.new
+      write.add(write1)
+      write.add(write2)
+    
+      app = Application.new("test")
+      app.subscribe(write)
+    
+      reset_test_adapter  # reset to make sure we read from redis
+      app = Application.new("test")
+      read = app.send(:subscriptions)
+    
+      read.size.should == 2
+      read1 = read.key("key1")
+      read2 = read.key("key2")
+      read1.should_not be_nil
+      read2.should_not be_nil
+      
+      read1.queue_name.should == "default"
+      read1.class_name.should == "MyClass1"
+      read2.queue_name.should == "else_ok"
+      read2.class_name.should == "MyClass2"
+      
+      read1.matches?("bus_event_type" => "event_one").should  == true
+      read1.matches?("bus_event_type" => "event_one1").should == false
+      read1.matches?("bus_event_type" => "aevent_one").should == false
+      
+      read2.matches?("bus_event_type" => "ahere").should == true
+      read2.matches?("bus_event_type" => "bhere").should == true
+      read2.matches?("bus_event_type" => "qhere").should == false
+      read2.matches?("bus_event_type" => "abhere").should == false
+      read2.matches?("bus_event_type" => "[ab]here").should == false
+      
+    end
+  end
+end

data/spec/matcher_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+module QueueBus
+  describe Matcher do
+    it "should already return false on empty filters" do
+      matcher = Matcher.new({})
+      matcher.matches?({}).should  == false
+      matcher.matches?(nil).should  == false
+      matcher.matches?("name" => "val").should == false
+    end
+
+    it "should not crash if nil inputs" do
+      matcher = Matcher.new("name" => "val")
+      matcher.matches?(nil).should == false
+    end
+
+    it "string filter to/from redis" do
+      matcher = Matcher.new("name" => "val")
+      matcher.matches?("name" => "val").should   == true
+      matcher.matches?("name" => " val").should  == false
+      matcher.matches?("name" => "zval").should  == false
+    end
+
+    it "regex filter" do
+      matcher = Matcher.new("name" => /^[cb]a+t/)
+      matcher.matches?("name" => "cat").should == true
+      matcher.matches?("name" => "bat").should == true
+      matcher.matches?("name" => "caaaaat").should == true
+      matcher.matches?("name" => "ct").should == false
+      matcher.matches?("name" => "bcat").should == false
+    end
+
+    it "present filter" do
+      matcher = Matcher.new("name" => :present)
+      matcher.matches?("name" => "").should == false
+      matcher.matches?("name" => "cat").should == true
+      matcher.matches?("name" => "bear").should == true
+      matcher.matches?("other" => "bear").should == false
+    end
+
+    it "blank filter" do
+      matcher = Matcher.new("name" => :blank)
+      matcher.matches?("name" => nil).should == true
+      matcher.matches?("other" => "bear").should == true
+      matcher.matches?("name" => "").should == true
+      matcher.matches?("name" => "  ").should == true
+      matcher.matches?("name" => "bear").should == false
+      matcher.matches?("name" => "   s ").should == false
+    end
+
+    it "nil filter" do
+      matcher = Matcher.new("name" => :nil)
+      matcher.matches?("name" => nil).should == true
+      matcher.matches?("other" => "bear").should == true
+      matcher.matches?("name" => "").should == false
+      matcher.matches?("name" => "  ").should == false
+      matcher.matches?("name" => "bear").should == false
+    end
+
+    it "key filter" do
+      matcher = Matcher.new("name" => :key)
+      matcher.matches?("name" => nil).should == true
+      matcher.matches?("other" => "bear").should == false
+      matcher.matches?("name" => "").should == true
+      matcher.matches?("name" => "  ").should == true
+      matcher.matches?("name" => "bear").should == true
+    end
+
+    it "empty filter" do
+      matcher = Matcher.new("name" => :empty)
+      matcher.matches?("name" => nil).should == false
+      matcher.matches?("other" => "bear").should == false
+      matcher.matches?("name" => "").should == true
+      matcher.matches?("name" => "  ").should == false
+      matcher.matches?("name" => "bear").should == false
+      matcher.matches?("name" => "   s ").should == false
+    end
+
+    it "value filter" do
+      matcher = Matcher.new("name" => :value)
+      matcher.matches?("name" => nil).should == false
+      matcher.matches?("other" => "bear").should == false
+      matcher.matches?("name" => "").should == true
+      matcher.matches?("name" => "  ").should == true
+      matcher.matches?("name" => "bear").should == true
+      matcher.matches?("name" => "   s ").should == true
+    end
+
+    it "multiple filters" do
+      matcher = Matcher.new("name" => /^[cb]a+t/, "state" => "sleeping")
+      matcher.matches?("state" => "sleeping", "name" => "cat").should  == true
+      matcher.matches?("state" => "awake", "name" => "cat").should     == false
+      matcher.matches?("state" => "sleeping", "name" => "bat").should  == true
+      matcher.matches?("state" => "sleeping", "name" => "bear").should == false
+      matcher.matches?("state" => "awake", "name" => "bear").should    == false
+    end
+
+    it "regex should go back and forth into redis" do
+      matcher = Matcher.new("name" => /^[cb]a+t/)
+      matcher.matches?("name" => "cat").should == true
+      matcher.matches?("name" => "bat").should == true
+      matcher.matches?("name" => "caaaaat").should == true
+      matcher.matches?("name" => "ct").should == false
+      matcher.matches?("name" => "bcat").should == false
+
+      QueueBus.redis { |redis| redis.set("temp1", QueueBus::Util.encode(matcher.to_redis) ) }
+      redis = QueueBus.redis { |redis| redis.get("temp1") }
+      matcher = Matcher.new(QueueBus::Util.decode(redis))
+      matcher.matches?("name" => "cat").should == true
+      matcher.matches?("name" => "bat").should == true
+      matcher.matches?("name" => "caaaaat").should == true
+      matcher.matches?("name" => "ct").should == false
+      matcher.matches?("name" => "bcat").should == false
+
+      QueueBus.redis { |redis| redis.set("temp2", QueueBus::Util.encode(matcher.to_redis) ) }
+      redis = QueueBus.redis { |redis| redis.get("temp2") }
+      matcher = Matcher.new(QueueBus::Util.decode(redis))
+      matcher.matches?("name" => "cat").should == true
+      matcher.matches?("name" => "bat").should == true
+      matcher.matches?("name" => "caaaaat").should == true
+      matcher.matches?("name" => "ct").should == false
+      matcher.matches?("name" => "bcat").should == false
+    end
+
+    it "special value should go back and forth into redis" do
+      matcher = Matcher.new("name" => :blank)
+      matcher.matches?("name" => "cat").should == false
+      matcher.matches?("name" => "").should    == true
+
+      QueueBus.redis { |redis| redis.set("temp1", QueueBus::Util.encode(matcher.to_redis) ) }
+      redis= QueueBus.redis { |redis| redis.get("temp1") }
+      matcher = Matcher.new(QueueBus::Util.decode(redis))
+      matcher.matches?("name" => "cat").should == false
+      matcher.matches?("name" => "").should    == true
+
+      QueueBus.redis { |redis| redis.set("temp2", QueueBus::Util.encode(matcher.to_redis) ) }
+      redis= QueueBus.redis { |redis| redis.get("temp2") }
+      matcher = Matcher.new(QueueBus::Util.decode(redis))
+      matcher.matches?("name" => "cat").should == false
+      matcher.matches?("name" => "").should    == true
+    end
+  end
+end

data/spec/publish_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe "Publishing an event" do
+
+  before(:each) do
+    Timecop.freeze
+    QueueBus.stub(:generate_uuid).and_return("idfhlkj")
+  end
+  after(:each) do
+    Timecop.return
+  end
+  let(:bus_attrs) { {"bus_published_at" => Time.now.to_i,
+                     "bus_id"=>"#{Time.now.to_i}-idfhlkj",
+                     "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
+
+  it "should add it to Redis" 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(event_name, hash)
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    hash = JSON.parse(val)
+    hash["class"].should == "QueueBus::Driver"
+    hash["args"].should == [ {"bus_event_type" => event_name, "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs) ]
+
+  end
+
+  it "should use the id if given" do
+    hash = {:one => 1, "two" => "here", "bus_id" => "app-given" }
+    event_name = "event_name"
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val.should == nil
+
+    QueueBus.publish(event_name, hash)
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    hash = JSON.parse(val)
+    hash["class"].should == "QueueBus::Driver"
+    hash["args"].should == [ {"bus_event_type" => event_name, "two"=>"here", "one"=>1}.merge(bus_attrs).merge("bus_id" => 'app-given') ]
+  end
+
+  it "should add metadata via callback" do
+    myval = 0
+    QueueBus.before_publish = lambda { |att|
+      att["mine"] = 4
+      myval += 1
+    }
+
+    hash = {:one => 1, "two" => "here", "bus_id" => "app-given" }
+    event_name = "event_name"
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val.should == nil
+
+    QueueBus.publish(event_name, hash)
+
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    hash = JSON.parse(val)
+    att = hash["args"].first
+    att["mine"].should == 4
+    myval.should == 1
+  end
+
+  it "should set the timezone and locale if available" do
+    defined?(I18n).should be_nil
+    Time.respond_to?(:zone).should eq(false)
+
+    stub_const("I18n", Class.new)
+    I18n.stub(:locale).and_return("jp")
+
+    Time.stub(:zone).and_return(double('zone', :name => "EST"))
+
+    hash = {:one => 1, "two" => "here", "bus_id" => "app-given" }
+    event_name = "event_name"
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val.should == nil
+
+    QueueBus.publish(event_name, hash)
+
+    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    hash = JSON.parse(val)
+    hash["class"].should == "QueueBus::Driver"
+    att = hash["args"].first
+    att["bus_locale"].should == "jp"
+    att["bus_timezone"].should == "EST"
+  end
+
+end

data/spec/publisher_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+module QueueBus
+  describe Publisher do
+    it "should call publish as expected"
+  end
+end

data/spec/rider_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module QueueBus
+  describe Rider do
+    it "should call execute" do
+      QueueBus.should_receive(:dispatcher_execute)
+      Rider.perform("bus_rider_app_key" => "app", "bus_rider_sub_key" => "sub", "ok" => true, "bus_event_type" => "event_name")
+    end
+
+    it "should change the value" do
+      QueueBus.dispatch("r1") do
+        subscribe "event_name" do |attributes|
+          Runner1.run(attributes)
+        end
+      end
+      Runner1.value.should == 0
+      Rider.perform("bus_locale" => "en", "bus_timezone" => "PST", "bus_rider_app_key" => "r1", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
+      Rider.perform("bus_rider_app_key" => "other", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
+      Runner1.value.should == 1
+    end
+
+    it "should set the timezone and locale if present" do
+      QueueBus.dispatch("r1") do
+        subscribe "event_name" do |attributes|
+          Runner1.run(attributes)
+        end
+      end
+
+      defined?(I18n).should be_nil
+      Time.respond_to?(:zone).should eq(false)
+
+      stub_const("I18n", Class.new)
+      I18n.should_receive(:locale=).with("en")
+      Time.should_receive(:zone=).with("PST")
+
+      Rider.perform("bus_locale" => "en", "bus_timezone" => "PST", "bus_rider_app_key" => "r1", "bus_rider_sub_key" => "event_name", "ok" => true, "bus_event_type" => "event_name")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,69 @@
+require 'timecop'
+require 'queue-bus'
+require 'adapter/support'
+
+reset_test_adapter
+
+module QueueBus
+  class Runner
+    def self.value
+      @value ||= 0
+    end
+
+    def self.attributes
+      @attributes
+    end
+
+    def self.run(attrs)
+      @value ||= 0
+      @value += 1
+      @attributes = attrs
+    end
+
+    def self.reset
+      @value = nil
+      @attributes = nil
+    end
+  end
+
+  class Runner1 < Runner
+  end
+
+  class Runner2 < Runner
+  end
+end
+
+def test_sub(event_name, queue="default")
+  matcher = {"bus_event_type" => event_name}
+  QueueBus::Subscription.new(queue, event_name, "::QueueBus::Rider", matcher, nil)
+end
+
+def test_list(*args)
+  out = QueueBus::SubscriptionList.new
+  args.each do |sub|
+    out.add(sub)
+  end
+  out
+end
+
+RSpec.configure do |config|
+  config.mock_with :rspec do |c|
+    c.syntax = :should
+  end
+  config.expect_with :rspec do |c|
+    c.syntax = :should
+  end
+
+  config.before(:each) do
+    reset_test_adapter
+  end
+  config.after(:each) do
+    begin
+      QueueBus.redis { |redis| redis.flushall }
+    rescue
+    end
+    QueueBus.send(:reset)
+    QueueBus::Runner1.reset
+    QueueBus::Runner2.reset
+  end
+end