message_bus 2.0.0.beta.2 → 2.0.0.beta.3

data/spec/lib/message_bus/backends/postgres_spec.rb

@@ -0,0 +1,208 @@
+require_relative '../../../spec_helper'
+require 'message_bus'
+
+if MESSAGE_BUS_CONFIG[:backend] == :postgres
+describe PUB_SUB_CLASS do
+
+  def new_test_bus
+    PUB_SUB_CLASS.new(MESSAGE_BUS_CONFIG.merge(:db => 10))
+  end
+
+  before do
+    @bus = new_test_bus
+    @bus.reset!
+  end
+
+  describe "readonly" do
+
+    after do
+      @bus.pub_redis.slaveof "no", "one"
+    end
+
+    it "should be able to store messages in memory for a period while in read only" do
+
+      skip "This spec changes redis behavior that in turn means other specs run slow"
+
+      @bus.pub_redis.slaveof "127.0.0.80", "666"
+      @bus.max_in_memory_publish_backlog = 2
+
+      3.times do
+        result = @bus.publish "/foo", "bar"
+        result.must_equal nil
+      end
+
+      @bus.pub_redis.slaveof "no", "one"
+      sleep 0.01
+
+      @bus.backlog("/foo", 0).map(&:data).must_equal ["bar","bar"]
+
+    end
+  end
+
+  it "should be able to access the backlog" do
+    @bus.publish "/foo", "bar"
+    @bus.publish "/foo", "baz"
+
+    @bus.backlog("/foo", 0).to_a.must_equal [
+      MessageBus::Message.new(1,1,'/foo','bar'),
+      MessageBus::Message.new(2,2,'/foo','baz')
+    ]
+  end
+
+  it "should initialize with max_backlog_size" do
+    PUB_SUB_CLASS.new({},2000).max_backlog_size.must_equal 2000
+  end
+
+  it "should truncate channels correctly" do
+    @bus.max_backlog_size = 2
+    4.times do |t|
+      @bus.publish "/foo", t.to_s
+    end
+
+    @bus.backlog("/foo").to_a.must_equal [
+      MessageBus::Message.new(3,3,'/foo','2'),
+      MessageBus::Message.new(4,4,'/foo','3'),
+    ]
+  end
+
+  it "should truncate global backlog correctly" do
+    @bus.max_global_backlog_size = 2
+    @bus.publish "/foo", "1"
+    @bus.publish "/bar", "2"
+    @bus.publish "/baz", "3"
+
+    @bus.global_backlog.length.must_equal 2
+  end
+
+  it "should be able to grab a message by id" do
+    id1 = @bus.publish "/foo", "bar"
+    id2 = @bus.publish "/foo", "baz"
+    @bus.get_message("/foo", id2).must_equal MessageBus::Message.new(2, 2, "/foo", "baz")
+    @bus.get_message("/foo", id1).must_equal MessageBus::Message.new(1, 1, "/foo", "bar")
+  end
+
+  it "should be able to access the global backlog" do
+    @bus.publish "/foo", "bar"
+    @bus.publish "/hello", "world"
+    @bus.publish "/foo", "baz"
+    @bus.publish "/hello", "planet"
+
+    @bus.global_backlog.to_a.must_equal [
+      MessageBus::Message.new(1, 1, "/foo", "bar"),
+      MessageBus::Message.new(2, 2, "/hello", "world"),
+      MessageBus::Message.new(3, 3, "/foo", "baz"),
+      MessageBus::Message.new(4, 4, "/hello", "planet")
+    ]
+  end
+
+  it "should correctly omit dropped messages from the global backlog" do
+    @bus.max_backlog_size = 1
+    @bus.publish "/foo", "a"
+    @bus.publish "/foo", "b"
+    @bus.publish "/bar", "a"
+    @bus.publish "/bar", "b"
+
+    @bus.global_backlog.to_a.must_equal [
+      MessageBus::Message.new(2, 2, "/foo", "b"),
+      MessageBus::Message.new(4, 4, "/bar", "b")
+    ]
+  end
+
+  it "should have the correct number of messages for multi threaded access" do
+    threads = []
+    4.times do
+      threads << Thread.new do
+        bus = new_test_bus
+        25.times {
+          bus.publish "/foo", "."
+        }
+      end
+    end
+
+    threads.each{|t| t.join}
+    @bus.backlog("/foo").length == 100
+  end
+
+  it "should be able to subscribe globally with recovery" do
+    @bus.publish("/foo", "1")
+    @bus.publish("/bar", "2")
+    got = []
+
+    t = Thread.new do
+      new_test_bus.global_subscribe(0) do |msg|
+        got << msg
+      end
+    end
+
+    @bus.publish("/bar", "3")
+
+    wait_for(100) do
+      got.length == 3
+    end
+
+    t.kill
+
+    got.length.must_equal 3
+    got.map{|m| m.data}.must_equal ["1","2","3"]
+  end
+
+  it "should be able to encode and decode messages properly" do
+    m = MessageBus::Message.new 1,2,'||','||'
+    MessageBus::Message.decode(m.encode).must_equal m
+  end
+
+  it "should handle subscribe on single channel, with recovery" do
+    @bus.publish("/foo", "1")
+    @bus.publish("/bar", "2")
+    got = []
+
+    t = Thread.new do
+      new_test_bus.subscribe("/foo",0) do |msg|
+        got << msg
+      end
+    end
+
+    @bus.publish("/foo", "3")
+
+    wait_for(100) do
+      got.length == 2
+    end
+
+    t.kill
+
+    got.map{|m| m.data}.must_equal ["1","3"]
+  end
+
+  it "should not get backlog if subscribe is called without params" do
+    @bus.publish("/foo", "1")
+    got = []
+
+    t = Thread.new do
+      new_test_bus.subscribe("/foo") do |msg|
+        got << msg
+      end
+    end
+
+    # sleep 50ms to allow the bus to correctly subscribe,
+    #   I thought about adding a subscribed callback, but outside of testing it matters less
+    sleep 0.05
+
+    @bus.publish("/foo", "2")
+
+    wait_for(100) do
+      got.length == 1
+    end
+
+    t.kill
+
+    got.map{|m| m.data}.must_equal ["2"]
+  end
+
+  it "should allow us to get last id on a channel" do
+    @bus.last_id("/foo").must_equal 0
+    @bus.publish("/foo", "1")
+    @bus.last_id("/foo").must_equal 1
+  end
+
+end
+end

data/spec/lib/message_bus/{redis/reliable_pub_sub_spec.rb → backends/redis_spec.rb}

@@ -1,10 +1,11 @@
-require 'spec_helper'
+require_relative '../../../spec_helper'
 require 'message_bus'
 
-describe MessageBus::Redis::ReliablePubSub do
+if MESSAGE_BUS_CONFIG[:backend] == :redis
+describe PUB_SUB_CLASS do
 
   def new_test_bus
-    MessageBus::Redis::ReliablePubSub.new(:db => 10)
+    PUB_SUB_CLASS.new(MESSAGE_BUS_CONFIG.merge(:db => 10))
   end
 
   before do
@@ -12,7 +13,7 @@ describe MessageBus::Redis::ReliablePubSub do
     @bus.reset!
   end
 
-  context "readonly" do
+  describe "readonly" do
 
     after do
       @bus.pub_redis.slaveof "no", "one"
@@ -27,13 +28,13 @@ describe MessageBus::Redis::ReliablePubSub do
 
       3.times do
         result = @bus.publish "/foo", "bar"
-        result.should == nil
+        result.must_equal nil
       end
 
       @bus.pub_redis.slaveof "no", "one"
       sleep 0.01
 
-      @bus.backlog("/foo", 0).map(&:data).should == ["bar","bar"]
+      @bus.backlog("/foo", 0).map(&:data).must_equal ["bar","bar"]
 
     end
   end
@@ -41,22 +42,22 @@ describe MessageBus::Redis::ReliablePubSub do
   it "can set backlog age" do
     @bus.max_backlog_age = 100
     @bus.publish "/foo", "bar"
-    @bus.pub_redis.ttl(@bus.backlog_key("/foo")).should be <= 100
-    @bus.pub_redis.ttl(@bus.backlog_key("/foo")).should be > 0
+    @bus.pub_redis.ttl(@bus.backlog_key("/foo")).must_be :<=, 100
+    @bus.pub_redis.ttl(@bus.backlog_key("/foo")).must_be :>, 0
   end
 
   it "should be able to access the backlog" do
     @bus.publish "/foo", "bar"
     @bus.publish "/foo", "baz"
 
-    @bus.backlog("/foo", 0).to_a.should == [
+    @bus.backlog("/foo", 0).to_a.must_equal [
       MessageBus::Message.new(1,1,'/foo','bar'),
       MessageBus::Message.new(2,2,'/foo','baz')
     ]
   end
 
   it "should initialize with max_backlog_size" do
-    MessageBus::Redis::ReliablePubSub.new({},2000).max_backlog_size.should == 2000
+    PUB_SUB_CLASS.new({},2000).max_backlog_size.must_equal 2000
   end
 
   it "should truncate channels correctly" do
@@ -65,7 +66,7 @@ describe MessageBus::Redis::ReliablePubSub do
       @bus.publish "/foo", t.to_s
     end
 
-    @bus.backlog("/foo").to_a.should == [
+    @bus.backlog("/foo").to_a.must_equal [
       MessageBus::Message.new(3,3,'/foo','2'),
       MessageBus::Message.new(4,4,'/foo','3'),
     ]
@@ -77,14 +78,14 @@ describe MessageBus::Redis::ReliablePubSub do
     @bus.publish "/bar", "2"
     @bus.publish "/baz", "3"
 
-    @bus.global_backlog.length.should == 2
+    @bus.global_backlog.length.must_equal 2
   end
 
   it "should be able to grab a message by id" do
     id1 = @bus.publish "/foo", "bar"
     id2 = @bus.publish "/foo", "baz"
-    @bus.get_message("/foo", id2).should == MessageBus::Message.new(2, 2, "/foo", "baz")
-    @bus.get_message("/foo", id1).should == MessageBus::Message.new(1, 1, "/foo", "bar")
+    @bus.get_message("/foo", id2).must_equal MessageBus::Message.new(2, 2, "/foo", "baz")
+    @bus.get_message("/foo", id1).must_equal MessageBus::Message.new(1, 1, "/foo", "bar")
   end
 
   it "should be able to access the global backlog" do
@@ -93,7 +94,7 @@ describe MessageBus::Redis::ReliablePubSub do
     @bus.publish "/foo", "baz"
     @bus.publish "/hello", "planet"
 
-    @bus.global_backlog.to_a.should == [
+    @bus.global_backlog.to_a.must_equal [
       MessageBus::Message.new(1, 1, "/foo", "bar"),
       MessageBus::Message.new(2, 1, "/hello", "world"),
       MessageBus::Message.new(3, 2, "/foo", "baz"),
@@ -108,7 +109,7 @@ describe MessageBus::Redis::ReliablePubSub do
     @bus.publish "/bar", "a"
     @bus.publish "/bar", "b"
 
-    @bus.global_backlog.to_a.should == [
+    @bus.global_backlog.to_a.must_equal [
       MessageBus::Message.new(2, 2, "/foo", "b"),
       MessageBus::Message.new(4, 2, "/bar", "b")
     ]
@@ -148,13 +149,13 @@ describe MessageBus::Redis::ReliablePubSub do
 
     t.kill
 
-    got.length.should == 3
-    got.map{|m| m.data}.should == ["1","2","3"]
+    got.length.must_equal 3
+    got.map{|m| m.data}.must_equal ["1","2","3"]
   end
 
   it "should be able to encode and decode messages properly" do
     m = MessageBus::Message.new 1,2,'||','||'
-    MessageBus::Message.decode(m.encode).should == m
+    MessageBus::Message.decode(m.encode).must_equal m
   end
 
   it "should handle subscribe on single channel, with recovery" do
@@ -176,7 +177,7 @@ describe MessageBus::Redis::ReliablePubSub do
 
     t.kill
 
-    got.map{|m| m.data}.should == ["1","3"]
+    got.map{|m| m.data}.must_equal ["1","3"]
   end
 
   it "should not get backlog if subscribe is called without params" do
@@ -201,13 +202,14 @@ describe MessageBus::Redis::ReliablePubSub do
 
     t.kill
 
-    got.map{|m| m.data}.should == ["2"]
+    got.map{|m| m.data}.must_equal ["2"]
   end
 
   it "should allow us to get last id on a channel" do
-    @bus.last_id("/foo").should == 0
+    @bus.last_id("/foo").must_equal 0
     @bus.publish("/foo", "1")
-    @bus.last_id("/foo").should == 1
+    @bus.last_id("/foo").must_equal 1
   end
 
 end
+end

data/spec/lib/message_bus/client_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require_relative '../../spec_helper'
 require 'message_bus'
 
 describe MessageBus::Client do
@@ -7,6 +7,7 @@ describe MessageBus::Client do
 
     before do
       @bus = MessageBus::Instance.new
+      @bus.redis_config = MESSAGE_BUS_CONFIG
       @client = MessageBus::Client.new client_id: 'abc', message_bus: @bus
     end
 
@@ -60,36 +61,36 @@ describe MessageBus::Client do
 
       status, headers, chunks = http_parse(lines)
 
-      headers["Content-Type"].should == "text/plain; charset=utf-8"
-      status.should == "200"
-      chunks.length.should == 2
+      headers["Content-Type"].must_equal "text/plain; charset=utf-8"
+      status.must_equal "200"
+      chunks.length.must_equal 2
 
       chunk1 = parse_chunk(chunks[0])
-      chunk1.length.should == 1
-      chunk1.first["data"].should == 'test'
+      chunk1.length.must_equal 1
+      chunk1.first["data"].must_equal 'test'
 
       chunk2 = parse_chunk(chunks[1])
-      chunk2.length.should == 1
-      chunk2.first["data"].should == "a|\r\n|\r\n|b"
+      chunk2.length.must_equal 1
+      chunk2.first["data"].must_equal "a|\r\n|\r\n|b"
 
       @client << MessageBus::Message.new(3, 3, '/test', 'test3')
       @client.close
 
       data = r.read
 
-      data[-5..-1].should == "0\r\n\r\n"
+      data[-5..-1].must_equal "0\r\n\r\n"
 
       _,_,chunks = http_parse("HTTP/1.1 200 OK\r\n\r\n" << data)
 
-      chunks.length.should == 2
+      chunks.length.must_equal 2
 
       chunk1 = parse_chunk(chunks[0])
-      chunk1.length.should == 1
-      chunk1.first["data"].should == 'test3'
+      chunk1.length.must_equal 1
+      chunk1.first["data"].must_equal 'test3'
 
       # end with []
       chunk2 = parse_chunk(chunks[1])
-      chunk2.length.should == 0
+      chunk2.length.must_equal 0
 
     end
 
@@ -99,7 +100,7 @@ describe MessageBus::Client do
       @client.subscribe('/hello', nil)
       @bus.publish '/hello', 'world'
       log = @client.backlog
-      log.length.should == 0
+      log.length.must_equal 0
     end
 
     it "does not bleed status accross sites" do
@@ -108,41 +109,41 @@ describe MessageBus::Client do
       @client.subscribe('/hello', -1)
       @bus.publish '/hello', 'world'
       log = @client.backlog
-      log[0].data.should == {"/hello" => 0}
+      log[0].data.must_equal("/hello" => 0)
     end
 
     it "provides status" do
       @client.subscribe('/hello', -1)
       log = @client.backlog
-      log.length.should == 1
-      log[0].data.should == {"/hello" => 0}
+      log.length.must_equal 1
+      log[0].data.must_equal("/hello" => 0)
     end
 
     it "should provide a list of subscriptions" do
       @client.subscribe('/hello', nil)
-      @client.subscriptions['/hello'].should_not be_nil
+      @client.subscriptions['/hello'].wont_equal nil
     end
 
     it "should provide backlog for subscribed channel" do
       @client.subscribe('/hello', nil)
       @bus.publish '/hello', 'world'
       log = @client.backlog
-      log.length.should == 1
-      log[0].channel.should == '/hello'
-      log[0].data.should == 'world'
+      log.length.must_equal 1
+      log[0].channel.must_equal '/hello'
+      log[0].data.must_equal 'world'
     end
 
     it "allows only client_id in list if message contains client_ids" do
       @message = MessageBus::Message.new(1, 2, '/test', 'hello')
       @message.client_ids = ["1","2"]
       @client.client_id = "2"
-      @client.allowed?(@message).should == true
+      @client.allowed?(@message).must_equal true
 
       @client.client_id = "3"
-      @client.allowed?(@message).should == false
+      @client.allowed?(@message).must_equal false
     end
 
-    context "targetted at group" do
+    describe "targetted at group" do
       before do
         @message = MessageBus::Message.new(1,2,'/test', 'hello')
         @message.group_ids = [1,2,3]
@@ -150,18 +151,18 @@ describe MessageBus::Client do
 
       it "denies users that are not members of group" do
         @client.group_ids = [77,0,10]
-        @client.allowed?(@message).should == false
+        @client.allowed?(@message).must_equal false
       end
 
       it "allows users that are members of group" do
         @client.group_ids = [1,2,3]
-        @client.allowed?(@message).should == true
+        @client.allowed?(@message).must_equal true
       end
 
       it "allows all users if groups not set" do
         @message.group_ids = nil
         @client.group_ids = [77,0,10]
-        @client.allowed?(@message).should == true
+        @client.allowed?(@message).must_equal true
       end
 
     end