resque-bus 0.2.3

data/spec/application_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+module ResqueBus
+  describe Application do
+    describe ".all" do
+      it "should return empty array when none" do
+        Application.all.should == []
+      end
+      it "should return registered applications when there are some" do
+        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")
+        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
+        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"]
+      end
+      it "should add string to redis" do
+        ResqueBus.redis.get("resquebus_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"]
+      end
+      it "should multiple queues to redis" do
+        ResqueBus.redis.get("resquebus_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"]
+      end
+    
+      it "should do nothing if nil or empty" do
+      
+        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
+      
+        Application.new("myapp").subscribe(nil)
+        ResqueBus.redis.get("resquebus_app:myapp").should be_nil
+      
+        Application.new("myapp").subscribe([])
+        ResqueBus.redis.get("resquebus_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")
+      
+        Application.new("myapp").unsubscribe
+      
+        ResqueBus.redis.smembers("resquebus_apps").should == ["other"]
+        ResqueBus.redis.get("resquebus_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"]]
+      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"]]
+      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"]]
+      end
+    end
+  end
+end

data/spec/dispatch_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper' 
+
+module ResqueBus
+  describe Dispatch do
+    it "should not start with any applications" do
+      Dispatch.new("d").subscriptions.size.should == 0
+    end
+    
+    it "should register code to run and execute it" do
+      dispatch = Dispatch.new("d")
+      dispatch.subscribe("my_event") do |attrs|
+        Runner1.run(attrs)
+      end
+      sub = dispatch.subscriptions.key("my_event")
+      sub.send(:executor).is_a?(Proc).should == true
+
+      Runner.value.should == 0
+      dispatch.execute("my_event", {"bus_event_type" => "my_event", "ok" => true})
+      Runner1.value.should == 1
+      Runner1.attributes.should == {"bus_event_type" => "my_event", "ok" => true}
+      
+    end
+    
+    it "should not crash if not there" do
+      lambda {
+        Dispatch.new("d").execute("fdkjh", "bus_event_type" => "fdkjh")
+      }.should_not raise_error
+    end
+    
+    describe "Top Level" do
+      before(:each) do
+         ResqueBus.dispatch("testit") do
+           subscribe "event1" do |attributes|
+             Runner2.run(attributes)
+           end
+
+           subscribe "event2" do
+             Runner2.run({})
+           end
+
+           high "event3" do
+             Runner2.run({})
+           end
+           
+           low /^patt.+ern/ do
+             Runner.run({})
+           end
+         end
+       end
+       
+      it "should register and run" do
+        Runner2.value.should == 0
+        ResqueBus.dispatcher_execute("testit", "event2", "bus_event_type" => "event2")
+        Runner2.value.should == 1
+        ResqueBus.dispatcher_execute("testit", "event1", "bus_event_type" => "event1")
+        Runner2.value.should == 2
+        ResqueBus.dispatcher_execute("testit", "event1", "bus_event_type" => "event1")
+        Runner2.value.should == 3
+      end
+      
+      it "should return the subscriptions" do
+        dispatcher = ResqueBus.dispatcher_by_key("testit")
+        subs = dispatcher.subscriptions.all
+        tuples = subs.collect{ |sub| [sub.key, sub.queue_name]}
+        tuples.should =~ [  ["event1", "testit_default"],
+                            ["event2", "testit_default"],
+                            ["event3", "testit_high"],
+                            [ "(?-mix:^patt.+ern)", "testit_low"]
+                         ]
+      end
+    
+    end
+  end
+
+end
+

data/spec/driver_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+module ResqueBus
+  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"=>"::ResqueBus::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", "::ResqueBus::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", "::ResqueBus::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", "::ResqueBus::Rider"], ["app2", "event2", "other", "::ResqueBus::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", "::ResqueBus::Rider"], ["app2", "event4", "more", "::ResqueBus::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", "::ResqueBus::Rider"], ["app3", "event5", "default", "::ResqueBus::Rider"]]
+      end
+    end
+    
+    describe ".peform" do
+      let(:attributes) { {"x" => "y"} }
+      
+      before(:each) do
+        ResqueBus.redis.smembers("queues").should == []
+        ResqueBus.redis.lpop("queue:app1_default").should be_nil
+        ResqueBus.redis.lpop("queue:app2_default").should be_nil
+        ResqueBus.redis.lpop("queue:app3_default").should be_nil
+      end
+      
+      it "should do nothing when empty" do
+        Driver.perform(attributes.merge("bus_event_type" => "else"))
+        ResqueBus.redis.smembers("queues").should == []
+      end
+      
+      it "should queue up the riders in redis" do
+        ResqueBus.redis.lpop("queue:app1_default").should be_nil
+        Driver.perform(attributes.merge("bus_event_type" => "event1"))
+        ResqueBus.redis.smembers("queues").should =~ ["default"]
+
+        hash = JSON.parse(ResqueBus.redis.lpop("queue:default"))
+        hash["class"].should == "::ResqueBus::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"))
+        ResqueBus.redis.smembers("queues").should =~ ["default", "more"]
+
+        hash = JSON.parse(ResqueBus.redis.lpop("queue:more"))
+        hash["class"].should == "::ResqueBus::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(ResqueBus.redis.lpop("queue:default"))
+        hash["class"].should == "::ResqueBus::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"))
+        ResqueBus.redis.smembers("queues").should =~ ["default"]
+
+        ResqueBus.redis.llen("queue:default").should == 2
+        
+        hash = JSON.parse(ResqueBus.redis.lpop("queue:default"))
+        hash["class"].should == "::ResqueBus::Rider"
+        hash["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)
+        first = hash["args"][0]["bus_rider_sub_key"]
+        
+        hash = JSON.parse(ResqueBus.redis.lpop("queue:default"))
+        hash["class"].should == "::ResqueBus::Rider"
+        hash["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)
+        second= hash["args"][0]["bus_rider_sub_key"]
+        
+        if first == "event[45]"
+          second.should == "event5"
+        else
+          first.should == "event5"
+          second.should == "event[45]"
+        end
+      end
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module ResqueBus
+  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)
+    
+      ResqueBus.send(:reset)  # 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 ResqueBus
+  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
+      
+      ResqueBus.redis.set("temp1", Resque.encode(matcher.to_redis))
+      redis = ResqueBus.redis.get("temp1")
+      matcher = Matcher.new(Resque.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
+      
+      ResqueBus.redis.set("temp2", Resque.encode(matcher.to_redis))
+      redis = ResqueBus.redis.get("temp2")
+      matcher = Matcher.new(Resque.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
+      
+      ResqueBus.redis.set("temp1", Resque.encode(matcher.to_redis))
+      redis = ResqueBus.redis.get("temp1")
+      matcher = Matcher.new(Resque.decode(redis))
+      matcher.matches?("name" => "cat").should == false
+      matcher.matches?("name" => "").should    == true
+      
+      ResqueBus.redis.set("temp2", Resque.encode(matcher.to_redis))
+      redis = ResqueBus.redis.get("temp2")
+      matcher = Matcher.new(Resque.decode(redis))
+      matcher.matches?("name" => "cat").should == false
+      matcher.matches?("name" => "").should    == true
+    end
+  end
+end

data/spec/publish_at_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe "Publishing an event in the future" do
+  
+  before(:each) do
+    Timecop.freeze(now)
+    ResqueBus.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",
+                     "created_at" => now.to_i,
+                     "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"
+    ResqueBus.publish_at(future, event_name, hash)
+    
+    schedule = ResqueBus.redis.zrange("delayed_queue_schedule", 0, 1)
+    schedule.should == [future.to_i.to_s]
+    
+    val = ResqueBus.redis.lpop("delayed:#{future.to_i}")
+    hash = JSON.parse(val)
+
+    hash["class"].should == "ResqueBus::Publisher"
+    hash["args"].should == [ "event_name", {"bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs) ]
+    hash["queue"].should == "resquebus_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 = ResqueBus.redis.lpop("queue:resquebus_incoming")
+    val.should == nil
+    
+    ResqueBus.publish_at(future, event_name, hash)
+    
+    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
+    val.should == nil # nothing really added
+    
+    # process sceduler now
+    Resque::Scheduler.handle_delayed_items
+    
+    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
+    val.should == nil # nothing added yet
+    
+    # process scheduler in future
+    Timecop.freeze(worktime) do
+      Resque::Scheduler.handle_delayed_items
+      
+      # added
+      val = ResqueBus.redis.lpop("queue:resquebus_incoming")
+      hash = JSON.parse(val)
+      hash["class"].should == "ResqueBus::Publisher"
+      hash["args"].should == [ "event_name", {"bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs) ]
+      
+     ResqueBus::Publisher.perform(*hash["args"])
+     
+     val = ResqueBus.redis.lpop("queue:resquebus_incoming")
+     hash = JSON.parse(val)
+     hash["class"].should == "ResqueBus::Driver"
+     hash["args"].should == [ {"bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs) ]
+    end
+  end
+
+end

data/spec/publish_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "Publishing an event" do
+  
+  before(:each) do
+    Timecop.freeze
+    ResqueBus.stub(:generate_uuid).and_return("idfhlkj")
+  end
+  after(:each) do
+    Timecop.return
+  end
+  let(:bus_attrs) { {"bus_published_at" => Time.now.to_i,
+                     "created_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 = ResqueBus.redis.lpop("queue:resquebus_incoming")
+    val.should == nil
+    
+    ResqueBus.publish(event_name, hash)
+    
+    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
+    hash = JSON.parse(val)
+    hash["class"].should == "ResqueBus::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 = ResqueBus.redis.lpop("queue:resquebus_incoming")
+    val.should == nil
+    
+    ResqueBus.publish(event_name, hash)
+    
+    val = ResqueBus.redis.lpop("queue:resquebus_incoming")
+    hash = JSON.parse(val)
+    hash["class"].should == "ResqueBus::Driver"
+    hash["args"].should == [ {"bus_event_type" => event_name, "two"=>"here", "one"=>1}.merge(bus_attrs).merge("bus_id" => 'app-given') ]
+  end
+
+end