message_bus 0.0.2 → 0.9.3

data/spec/lib/message_handler_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'message_bus'
+
+describe MessageBus::MessageHandler do
+
+  it "should properly register message handlers" do
+    MessageBus::MessageHandler.handle "/hello" do |m|
+      m
+    end
+    MessageBus::MessageHandler.call("site","/hello", "world", 1).should == "world"
+  end
+
+  it "should correctly load message handlers" do
+    MessageBus::MessageHandler.load_handlers("#{File.dirname(__FILE__)}/handlers")
+    MessageBus::MessageHandler.call("site","/dupe", "1", 1).should == "11"
+  end
+
+  it "should allow for a connect / disconnect callback" do
+    MessageBus::MessageHandler.handle "/channel" do |m|
+      m
+    end
+
+    connected = false
+    disconnected = false
+
+    MessageBus.on_connect do |site_id|
+      connected = true
+    end
+    MessageBus.on_disconnect do |site_id|
+      disconnected = true
+    end
+
+    MessageBus::MessageHandler.call("site_id", "/channel", "data", 1)
+
+    connected.should == true
+    disconnected.should == true
+
+  end
+end

data/spec/lib/middleware_spec.rb

@@ -0,0 +1,306 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'message_bus'
+require 'rack/test'
+
+describe MessageBus::Rack::Middleware do
+  include Rack::Test::Methods
+
+  before do
+    MessageBus.long_polling_enabled = false
+  end
+
+  def app
+    @app ||= Rack::Builder.new {
+      use FakeAsyncMiddleware
+      use MessageBus::Rack::Middleware
+      run lambda {|env| [500, {'Content-Type' => 'text/html'}, 'should not be called' ]}
+    }.to_app
+  end
+
+  shared_examples "long polling" do
+    before do
+      MessageBus.long_polling_enabled = true
+    end
+
+    it "should respond right away if dlp=t" do
+      post "/message-bus/ABC?dlp=t", '/foo1' => 0
+      FakeAsyncMiddleware.in_async?.should == false
+      last_response.should be_ok
+    end
+
+    it "should respond right away to long polls that are polling on -1 with the last_id" do
+      post "/message-bus/ABC", '/foo' => -1
+      last_response.should be_ok
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 1
+      parsed[0]["channel"].should == "/__status"
+      parsed[0]["data"]["/foo"].should == MessageBus.last_id("/foo")
+    end
+
+    it "should respond to long polls when data is available" do
+
+      Thread.new do
+        wait_for(2000) { FakeAsyncMiddleware.in_async? }
+        MessageBus.publish "/foo", "םוֹלשָׁ"
+      end
+
+      post "/message-bus/ABC", '/foo' => nil
+
+      last_response.should be_ok
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 1
+      parsed[0]["data"].should == "םוֹלשָׁ"
+    end
+
+    it "should timeout within its alloted slot" do
+      begin
+        MessageBus.long_polling_interval = 10
+        s = Time.now.to_f * 1000
+        post "/message-bus/ABC", '/foo' => nil
+        (Time.now.to_f * 1000 - s).should < 30
+      ensure
+        MessageBus.long_polling_interval = 5000
+      end
+    end
+
+    it "should support batch filtering" do
+      MessageBus.user_id_lookup do |env|
+        1
+      end
+
+      MessageBus.around_client_batch("/demo") do |message, user_ids, callback|
+        begin
+          Thread.current["test"] = user_ids
+          callback.call
+        ensure
+          Thread.current["test"] = nil
+        end
+      end
+
+      test = nil
+
+      MessageBus.client_filter("/demo") do |user_id, message|
+        test = Thread.current["test"]
+        message
+      end
+
+      client_id = "ABCD"
+
+      id = MessageBus.publish("/demo", "test")
+
+      Thread.new do
+        wait_for(2000) { FakeAsyncMiddleware.in_async? }
+        MessageBus.publish "/demo", "test"
+      end
+
+      post "/message-bus/#{client_id}", {
+        '/demo' => id
+      }
+
+      test.should == [1]
+    end
+  end
+
+  describe "thin async" do
+    before do
+      FakeAsyncMiddleware.simulate_thin_async
+    end
+    it_behaves_like "long polling"
+  end
+
+  describe "hijack" do
+    before do
+      FakeAsyncMiddleware.simulate_hijack
+      MessageBus.rack_hijack_enabled = true
+    end
+    it_behaves_like "long polling"
+  end
+
+  describe "diagnostics" do
+
+    it "should return a 403 if a user attempts to get at the _diagnostics path" do
+      get "/message-bus/_diagnostics"
+      last_response.status.should == 403
+    end
+
+    it "should get a 200 with html for an authorized user" do
+      MessageBus.stub(:is_admin_lookup).and_return(lambda{|env| true })
+      get "/message-bus/_diagnostics"
+      last_response.status.should == 200
+    end
+
+    it "should get the script it asks for" do
+      MessageBus.stub(:is_admin_lookup).and_return(lambda{|env| true })
+      get "/message-bus/_diagnostics/assets/message-bus.js"
+      last_response.status.should == 200
+      last_response.content_type.should == "text/javascript;"
+    end
+
+  end
+
+  describe "polling" do
+    before do
+      MessageBus.long_polling_enabled = false
+    end
+
+    it "should respond with a 200 to a subscribe" do
+      client_id = "ABCD"
+
+      # client always keeps a list of channels with last message id they got on each
+      post "/message-bus/#{client_id}", {
+        '/foo' => nil,
+        '/bar' => nil
+      }
+      last_response.should be_ok
+    end
+
+    it "should correctly understand that -1 means stuff from now onwards" do
+
+      MessageBus.publish('foo', 'bar')
+
+      post "/message-bus/ABCD", {
+        '/foo' => -1
+      }
+      last_response.should be_ok
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 1
+      parsed[0]["channel"].should == "/__status"
+      parsed[0]["data"]["/foo"].should == MessageBus.last_id("/foo")
+
+    end
+
+    it "should respond with the data if messages exist in the backlog" do
+      id = MessageBus.last_id('/foo')
+
+      MessageBus.publish("/foo", "barbs")
+      MessageBus.publish("/foo", "borbs")
+
+      client_id = "ABCD"
+      post "/message-bus/#{client_id}", {
+        '/foo' => id,
+        '/bar' => nil
+      }
+
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 2
+      parsed[0]["data"].should == "barbs"
+      parsed[1]["data"].should == "borbs"
+    end
+
+    it "should not get consumed messages" do
+      MessageBus.publish("/foo", "barbs")
+      id = MessageBus.last_id('/foo')
+
+      client_id = "ABCD"
+      post "/message-bus/#{client_id}", {
+        '/foo' => id
+      }
+
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 0
+    end
+
+    it "should filter by user correctly" do
+      id = MessageBus.publish("/foo", "test", user_ids: [1])
+      MessageBus.user_id_lookup do |env|
+        0
+      end
+
+      client_id = "ABCD"
+      post "/message-bus/#{client_id}", {
+        '/foo' => id - 1
+      }
+
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 0
+
+      MessageBus.user_id_lookup do |env|
+        1
+      end
+
+      post "/message-bus/#{client_id}", {
+        '/foo' => id - 1
+      }
+
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 1
+    end
+
+
+    it "should filter by client_filter correctly" do
+      id = MessageBus.publish("/filter", "test")
+      user_id = 0
+
+      MessageBus.user_id_lookup do |env|
+        user_id
+      end
+
+      MessageBus.client_filter("/filter") do |user_id, message|
+        if user_id == 0
+          message = message.dup
+          message.data += "_filter"
+          message
+        elsif user_id == 1
+          message
+        end
+      end
+
+      client_id = "ABCD"
+
+      post "/message-bus/#{client_id}", {
+        '/filter' => id - 1
+      }
+
+      parsed = JSON.parse(last_response.body)
+      parsed[0]['data'].should == "test_filter"
+
+      user_id = 1
+
+      post "/message-bus/#{client_id}", {
+        '/filter' => id - 1
+      }
+
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 1
+      parsed[0]["data"].should == "test"
+
+      user_id = 2
+
+      post "/message-bus/#{client_id}", {
+        '/filter' => id - 1
+      }
+
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 0
+    end
+
+    it "should filter by group correctly" do
+      id = MessageBus.publish("/foo", "test", group_ids: [3,4,5])
+      MessageBus.group_ids_lookup do |env|
+        [0,1,2]
+      end
+
+      client_id = "ABCD"
+      post "/message-bus/#{client_id}", {
+        '/foo' => id - 1
+      }
+
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 0
+
+      MessageBus.group_ids_lookup do |env|
+        [1,7,4,100]
+      end
+
+      post "/message-bus/#{client_id}", {
+        '/foo' => id - 1
+      }
+
+      parsed = JSON.parse(last_response.body)
+      parsed.length.should == 1
+    end
+  end
+
+end

data/spec/lib/multi_process_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'message_bus'
+
+describe MessageBus::ReliablePubSub do
+
+  def new_bus
+    MessageBus::ReliablePubSub.new(:db => 10)
+  end
+
+  def work_it
+    Signal.trap("HUP") { exit }
+
+    bus = new_bus
+    $stdout.reopen("/dev/null", "w")
+    $stderr.reopen("/dev/null", "w")
+    # subscribe blocks, so we need a new bus to transmit
+    new_bus.subscribe("/echo", 0) do |msg|
+      bus.publish("/response", Process.pid.to_s)
+    end
+  end
+
+  def spawn_child
+    r = fork
+    if r.nil?
+      work_it
+    else
+      r
+    end
+  end
+
+  it 'gets every response from child processes' do
+    pid = nil
+    Redis.new(:db => 10).flushdb
+    begin
+      pids = (1..10).map{spawn_child}
+      responses = []
+      bus = MessageBus::ReliablePubSub.new(:db => 10)
+      Thread.new do
+        bus.subscribe("/response", 0) do |msg|
+          responses << msg if pids.include? msg.data.to_i
+        end
+      end
+      10.times{bus.publish("/echo", Process.pid.to_s)}
+      wait_for 4000 do
+        responses.count == 100
+      end
+
+      # p responses.group_by(&:data).map{|k,v|[k, v.count]}
+      # p responses.group_by(&:global_id).map{|k,v|[k, v.count]}
+      responses.count.should == 100
+    ensure
+      if pids
+        pids.each do |pid|
+          Process.kill("HUP", pid)
+          Process.wait(pid)
+        end
+      end
+    end
+  end
+end

data/spec/lib/reliable_pub_sub_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+require 'message_bus'
+
+describe MessageBus::ReliablePubSub do
+
+  def new_test_bus
+    MessageBus::ReliablePubSub.new(:db => 10)
+  end
+
+  before do
+    @bus = new_test_bus
+    @bus.reset!
+  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 == [
+      MessageBus::Message.new(1,1,'/foo','bar'),
+      MessageBus::Message.new(2,2,'/foo','baz')
+    ]
+  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.should == [
+      MessageBus::Message.new(3,3,'/foo','2'),
+      MessageBus::Message.new(4,4,'/foo','3'),
+    ]
+  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")
+  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.should == [
+      MessageBus::Message.new(1, 1, "/foo", "bar"),
+      MessageBus::Message.new(2, 1, "/hello", "world"),
+      MessageBus::Message.new(3, 2, "/foo", "baz"),
+      MessageBus::Message.new(4, 2, "/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.should == [
+      MessageBus::Message.new(2, 2, "/foo", "b"),
+      MessageBus::Message.new(4, 2, "/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.should == 3
+    got.map{|m| m.data}.should == ["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
+  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}.should == ["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}.should == ["2"]
+  end
+
+  it "should allow us to get last id on a channel" do
+    @bus.last_id("/foo").should == 0
+    @bus.publish("/foo", "1")
+    @bus.last_id("/foo").should == 1
+  end
+
+end