faye 0.5.5 → 0.6.0

data/lib/faye/protocol/connection.rb

@@ -1,111 +0,0 @@
-module Faye
-  class Connection
-    include EventMachine::Deferrable
-    include Publisher
-    include Timeouts
-    
-    MAX_DELAY = 0.001
-    INTERVAL  = 0.0
-    TIMEOUT   = 60.0
-    
-    attr_reader :id, :interval, :timeout
-    
-    def initialize(id, options = {})
-      @id        = id
-      @options   = options
-      @interval  = @options[:interval] || INTERVAL
-      @timeout   = @options[:timeout] || TIMEOUT
-      @channels  = Set.new
-      @inbox     = Set.new
-      @connected = false
-      
-      begin_deletion_timeout
-    end
-    
-    def socket=(socket)
-      @connected = true
-      @socket    = socket
-    end
-    
-    def on_message(event)
-      return unless @inbox.add?(event)
-      @socket.send(JSON.unparse(event)) if @socket
-      begin_delivery_timeout
-    end
-    
-    def subscribe(channel)
-      return unless @channels.add?(channel)
-      channel.add_subscriber(:message, method(:on_message))
-    end
-    
-    def unsubscribe(channel)
-      return @channels.each(&method(:unsubscribe)) if channel == :all
-      return unless @channels.member?(channel)
-      @channels.delete(channel)
-      channel.remove_subscriber(:message, method(:on_message))
-    end
-    
-    def connect(options, &block)
-      options = options || {}
-      timeout = options['timeout'] ? options['timeout'] / 1000.0 : @timeout
-      
-      set_deferred_status(:deferred)
-      
-      callback(&block)
-      return if @connected
-      
-      @connected = true
-      remove_timeout(:deletion)
-      
-      begin_delivery_timeout
-      begin_connection_timeout(timeout)
-    end
-    
-    def flush!
-      return unless @connected
-      release_connection!
-      
-      events = @inbox.entries
-      @inbox = Set.new
-      
-      set_deferred_status(:succeeded, events)
-      set_deferred_status(:deferred)
-    end
-    
-    def disconnect!
-      unsubscribe(:all)
-      flush!
-    end
-    
-  private
-    
-    def release_connection!
-      return if @socket
-      
-      remove_timeout(:connection)
-      remove_timeout(:delivery)
-      @connected = false
-      
-      begin_deletion_timeout
-    end
-    
-    def begin_delivery_timeout
-      return unless @connected and not @inbox.empty?
-      add_timeout(:delivery, MAX_DELAY) { flush! }
-    end
-    
-    def begin_connection_timeout(timeout)
-      return unless @connected
-      add_timeout(:connection, timeout) { flush! }
-    end
-    
-    def begin_deletion_timeout
-      return if @connected
-      add_timeout(:deletion, TIMEOUT + 10 * @timeout) do
-        publish_event(:stale_connection, self)
-      end
-    end
-    
-  end
-end
-

data/test/scenario.rb

@@ -1,172 +0,0 @@
-$VERBOSE = false
-
-module Scenario
-  module ClassMethods
-    def scenario(name, &block)
-      define_method("test: #{name}", &block)
-    end
-  end
-  
-  def self.included(klass)
-    klass.extend ClassMethods
-  end
-  
-  def setup
-    Thread.new { EM.run }
-    while not EM.reactor_running?; end
-    @scenario = AsyncScenario.new
-    @commands = []
-    @started = false
-  end
-  
-  def teardown
-    while EM.reactor_running?; end
-  end
-  
-  def run(runner)
-    @runner = runner
-    super
-  end
-  
-  def method_missing(sym, *args)
-    @commands << [sym, args]
-    EM.next_tick { run_next_command unless @started }
-  end
-  
-  def run_next_command
-    @started = true
-    command = @commands.shift
-    return finish if command.nil?
-    begin
-      @scenario.__send__(command.first, *command.last) do
-        run_next_command
-      end
-    rescue Object => e
-      @passed = false
-      add_failure(e.message, e.backtrace)
-      @runner.puke(self.class, self.name, e) if @runner.respond_to?(:puke)
-      block.call
-    end
-  end
-  
-  def finish
-    @scenario.finish { EM.stop }
-  end
-  
-  class AsyncScenario
-    include Test::Unit::Assertions
-    
-    def initialize
-      @clients = {}
-      @inbox   = {}
-      @errors  = {}
-      @pool    = 0
-    end
-    
-    def wait(time, &block)
-      EM.add_timer(time, &block)
-    end
-    
-    def server(port, &block)
-      @endpoint = "http://0.0.0.0:#{port}/bayeux"
-      @bayeux = Faye::RackAdapter.new(:mount => '/bayeux', :timeout => 30)
-      Rack::Handler.get('thin').run(@bayeux, :Port => port) do |server|
-        @server = server
-        EM.next_tick(&block)
-      end
-    end
-    
-    def http_client(name, channels = nil, &block)
-      setup_client(Faye::Client.new(@endpoint), name, channels, &block)
-    end
-    
-    def local_client(name, channels = nil, &block)
-      setup_client(@bayeux.get_client, name, channels, &block)
-    end
-    
-    def extend_server(stage, extension, &block)
-      object = Object.new
-      def object.added
-        @active = true
-      end
-      (class << object; self; end).send(:define_method, stage) do |*args|
-        extension.call(*args) if @active
-      end
-      @bayeux.add_extension(object)
-      block.call
-    end
-    
-    def extend_client(name, stage, extension, &block)
-      object = Object.new
-      (class << object; self; end).send(:define_method, stage, &extension)
-      @clients[name].add_extension(object)
-      block.call
-    end
-    
-    def listen_for_errors(name, &block)
-      @errors[name] = []
-      errors = @errors
-      
-      extend_client(name, :incoming, lambda { |message, callback|
-        if message['successful'] == false
-          errors[name] << message['error']
-        end
-        callback.call(message)
-      }, &block)
-    end
-    
-    def setup_client(client, name, channels, &block)
-      @clients[name] = client
-      @inbox[name]   = {}
-      @pool         += 1
-      
-      return block.call if channels.nil?
-      
-      channels.each { |channel| subscribe(name, channel) }
-      EM.add_timer(0.5 * channels.size, &block)
-    end
-    
-    def subscribe(name, channel, &block)
-      client = @clients[name]
-      
-      @last_sub = client.subscribe(channel) do |message|
-        box = @inbox[name]
-        box[channel] ||= []
-        box[channel] << message
-      end
-      
-      @last_sub.callback(&block)
-    end
-    
-    def cancel_last_subscription(&block)
-      @last_sub.cancel
-      EM.add_timer(0.5, &block)
-    end
-    
-    def publish(from, channel, messages, &block)
-      messages = [messages].flatten
-      messages.each { |msg| @clients[from].publish(channel, msg) }
-      EM.add_timer(2, &block)
-    end
-  
-    def check_inbox(expected_inbox, &block)
-      assert_equal expected_inbox, @inbox
-      EM.next_tick(&block)
-    end
-    
-    def check_errors(name, expected_errors, &block)
-      assert_equal expected_errors, @errors[name]
-      EM.next_tick(&block)
-    end
-    
-    def finish(&block)
-      @clients.each { |id,c| c.disconnect }
-      EM.add_timer(1) do
-        @server.stop!
-        block.call
-      end
-    end
-  end
-  
-end
-

data/test/test_channel.rb

@@ -1,54 +0,0 @@
-require "test/unit"
-require File.dirname(__FILE__) + "/../lib/faye"
-
-class TestChannel < Test::Unit::TestCase
-  include Faye
-  
-  def test_channel_storage
-    tree = Channel::Tree.new
-    tree['invalid/name']    = 1
-    tree['/valid/name']     = 2
-    tree['/va()$$lid/name'] = 3
-    
-    assert_equal nil, tree['invalid/name']
-    assert_equal 2,   tree['/valid/name']
-    assert_equal 3,   tree['/va()$$lid/name']
-  end
-  
-  def test_keys
-    tree = Channel::Tree.new
-    tree['/foo'] = tree['/bar'] = tree['/foo/bar'] = true
-    assert_equal %w[/bar /foo /foo/bar], tree.keys.sort
-  end
-  
-  def test_removal
-    tree = Channel::Tree.new
-    tree['/foo'] = tree['/bar'] = tree['/foo/bar'] = true
-    
-    tree.remove('/foo/bar')
-    assert_equal %w[/bar /foo], tree.keys.sort
-  end
-  
-  def test_globbing
-    tree = Channel::Tree.new
-    tree['/foo/bar']     = 1
-    tree['/foo/boo']     = 2
-    tree['/foo']         = 3
-    tree['/foobar']      = 4
-    tree['/foo/bar/boo'] = 5
-    tree['/foobar/boo']  = 6
-    tree['/foo/*']       = 7
-    tree['/foo/**']      = 8
-    
-    assert_equal  [1,2,7,8],    tree.glob('/foo/*').sort
-    assert_equal  [1,7,8],      tree.glob('/foo/bar').sort
-    assert_equal  [1,2,5,7,8],  tree.glob('/foo/**').sort
-    assert_equal  [5,8],        tree.glob('/foo/bar/boo').sort
-    
-    tree['/channels/hello'] = 'A'
-    tree['/channels/name'] = 'B'
-    tree['/channels/nested/hello'] = 'C'
-    
-    assert_equal %w[A B C],     tree.glob('/channels/**').sort
-  end
-end

data/test/test_clients.rb

@@ -1,381 +0,0 @@
-require "test/unit"
-require File.dirname(__FILE__) + "/../lib/faye"
-require "test/scenario"
-
-class TestClients < Test::Unit::TestCase
-  include Faye
-  include Scenario
-  
-  scenario "Client modifies incoming messages" do
-    server 8000
-    http_client :A, ['/channels/a']
-    http_client :B, ['/channels/b']
-    
-    extend_client :A, :incoming, lambda { |message, callback|
-      if message['data']
-        message['data']['modified'] = 'hi'
-      end
-      callback.call(message)
-    }
-    
-    publish :B, '/channels/a', 'welcome' => 'message'
-    check_inbox(
-        :A => {
-          '/channels/a' => ['welcome' => 'message', 'modified' => 'hi']
-        },
-        :B => {}
-    )
-  end
-  
-  scenario "Client blocks incoming messages" do
-    server 8000
-    http_client :A, ['/channels/a']
-    http_client :B, ['/channels/b']
-    
-    extend_client :A, :incoming, lambda { |message, callback|
-      callback.call(nil)
-    }
-    
-    publish :B, '/channels/a', 'welcome' => 'message'
-    check_inbox( :A => {}, :B => {} )
-  end
-  
-  scenario "Server requires authentication" do
-    server 8000
-    http_client :A, ['/channels/a']
-    http_client :B, ['/channels/b']
-    
-    extend_server :incoming, lambda { |message, callback|
-      if message['ext'] and message['ext']['password']
-        callback.call(message)
-      end
-    }
-    
-    extend_client :B, :outgoing, lambda { |message, callback|
-      message['ext'] = {'password' => true}
-      callback.call(message)
-    }
-    
-    publish :A, '/channels/b', 'message_for' => 'B'
-    check_inbox( :A => {}, :B => {} )
-    
-    publish :B, '/channels/a', 'message_for' => 'A'
-    check_inbox(
-        :A => {
-          '/channels/a' => ['message_for' => 'A']
-        },
-        :B => {}
-    )
-  end
-  
-  scenario "Server blocks a message by setting an error" do
-    server 8000
-    http_client :A, ['/channels/a']
-    http_client :B, ['/channels/b']
-    
-    extend_server :incoming, lambda { |message, callback|
-      if message['data']
-        message['error'] = Faye::Error.ext_mismatch
-      end
-      callback.call(message)
-    }
-    
-    listen_for_errors :A
-    
-    publish :A, '/channels/b', 'message_for' => 'B'
-    check_inbox( :A => {}, :B => {} )
-    check_errors :A, ['302::Extension mismatch']
-  end
-  
-  scenario "Server modifies outgoing message" do
-    server 8000
-    http_client :A, []
-    http_client :B, ['/channels/b']
-    
-    extend_server :outgoing, lambda { |message, callback|
-      message['data']['addition'] = 56 if message['data']
-      callback.call(message)
-    }
-    
-    publish :A, '/channels/b', 'message_for' => 'B'
-    check_inbox(
-        :A => {},
-        :B => {
-          '/channels/b' => ['message_for' => 'B', 'addition' => 56]
-        }
-    )
-  end
-  
-  [:incoming, :outgoing].each do |direction|
-    scenario "Server delays #{ direction } message" do
-      server 8000
-      http_client :A, []
-      http_client :B, ['/channels/b']
-      
-      extend_server direction, lambda { |message, callback|
-        timeout = message['data'] ? 5 : 0
-        EM.add_timer(timeout) { callback.call(message) }
-      }
-      
-      publish :A, '/channels/b', 'message_for' => 'B'
-      check_inbox( :A => {}, :B => {} )
-      
-      wait 3
-      check_inbox( :A => {}, :B => {} )
-      
-      wait 1
-      
-      check_inbox(
-          :A => {},
-          :B => {
-            '/channels/b' => ['message_for' => 'B']
-          }
-      )
-    end
-  end
-  
-  scenario "Server blocks outgoing message" do
-    server 8000
-    http_client :A, []
-    http_client :B, ['/channels/b']
-    
-    extend_server :outgoing, lambda { |message, callback|
-      if !message['data'] or message['data']['deliver'] == 'yes'
-        callback.call(message)
-      else
-        callback.call(nil)
-      end
-    }
-    
-    publish :A, '/channels/b', [{'deliver' => 'no'}, {'deliver' => 'yes'}]
-    
-    check_inbox(
-        :A => {},
-        :B => {
-          '/channels/b' => ['deliver' => 'yes']
-        }
-    )
-  end
-  
-  scenario "Two HTTP clients, no messages delivered" do
-    server 8000
-    http_client :A, ['/channels/a']
-    http_client :B, []
-    publish :B, '/channels/b', 'hello' => 'world'
-    check_inbox(
-      :A => {},
-      :B => {}
-    )
-  end
-  
-  scenario "Two HTTP clients, single subscription" do
-    server 8000
-    http_client :A, ['/channels/a']
-    http_client :B, []
-    publish :B, '/channels/a', 'hello' => 'world'
-    check_inbox(
-        :A => {
-          '/channels/a' => ['hello' => 'world']
-        },
-        :B => {}
-    )
-  end
-  
-  scenario "Two HTTP clients, two identical messages sent together" do
-    server 8000
-    http_client :A, ['/channels/a']
-    http_client :B, []
-    publish :B, '/channels/a', [{'hello' => 'world'}, {'hello' => 'world'}]
-    check_inbox(
-        :A => {
-          '/channels/a' => [{'hello' => 'world'}, {'hello' => 'world'}]
-        },
-        :B => {}
-    )
-  end
-  
-  scenario "Two HTTP clients, two message deliveries" do
-    server 8000
-    http_client :A, ['/channels/a']
-    http_client :B, []
-    publish :B, '/channels/a', 'hello' => 'world'
-    check_inbox(
-        :A => {
-          '/channels/a' => ['hello' => 'world']
-        },
-        :B => {}
-    )
-    wait 1
-    publish :B, '/channels/a', 'hello' => 'world'
-    check_inbox(
-        :A => {
-          '/channels/a' => [{'hello' => 'world'}, {'hello' => 'world'}]
-        },
-        :B => {}
-    )
-  end
-
-  scenario "Two HTTP clients, multiple subscriptions" do
-    server 8000
-    http_client :A, ['/channels/a', '/channels/*']
-    http_client :B, []
-    publish :B, '/channels/a', 'hello' => 'world'
-    check_inbox(
-        :A => {
-          '/channels/a' => ['hello' => 'world'],
-          '/channels/*' => ['hello' => 'world']
-        },
-        :B => {}
-    )
-  end
-  
-  scenario "One HTTP client, one local with no subscriptions" do
-    server 8000
-    http_client :A, ['/channels/a']
-    local_client :B
-    publish :B, '/channels/a', 'hello' => 'world'
-    
-    check_inbox(
-        :A => {
-          '/channels/a' => ['hello' => 'world']
-        },
-        :B => {}
-    )
-  end
-
-  scenario "Two HTTP clients, two subscriptions on the same channel" do
-    server 8000
-    http_client :A, ['/channels/a']
-    http_client :B, []
-    subscribe :A, '/channels/a'
-    publish :B, '/channels/a', 'hello' => 'world'
-    check_inbox(
-        :A => {
-          '/channels/a' => [{'hello' => 'world'}, {'hello' => 'world'}]
-        },
-        :B => {}
-    )
-  end
-
-  scenario "Two HTTP clients, two subscriptions and one unsubscription" do
-    server 8000
-    http_client :A, ['/channels/a']
-    http_client :B, []
-    subscribe :A, '/channels/a'
-    cancel_last_subscription
-    publish :B, '/channels/a', 'another' => 'message'
-    check_inbox(
-        :A => {
-          '/channels/a' => [{'another' => 'message'}]
-        },
-        :B => {}
-    )
-  end
-
-  scenario "Three HTTP clients, single receiver" do
-    server 8000
-    http_client :A, ['/channels/a']
-    http_client :B, []
-    http_client :C, ['/channels/c']
-    publish :B, '/channels/a', 'chunky' => 'bacon'
-    check_inbox(
-        :A => {
-          '/channels/a' => ['chunky' => 'bacon']
-        },
-        :B => {},
-        :C => {}
-    )
-  end
-
-  scenario "Three HTTP clients, multiple receivers" do
-    server 8000
-    http_client :A, ['/channels/shared']
-    http_client :B, []
-    http_client :C, ['/channels/shared']
-    publish :B, '/channels/shared', 'chunky' => 'bacon'
-    check_inbox(
-        :A => {
-          '/channels/shared' => ['chunky' => 'bacon']
-        },
-        :B => {},
-        :C => {
-          '/channels/shared' => ['chunky' => 'bacon']
-        }
-    )
-  end
-
-  scenario "Two HTTP clients, single wildcard on receiver" do
-    server 8000
-    http_client :A, ['/channels/*']
-    http_client :B, []
-    publish :B, '/channels/anything', 'msg' => 'hey'
-    check_inbox(
-        :A => {
-          '/channels/*' => ['msg' => 'hey']
-        },
-        :B => {}
-    )
-  end
-
-  scenario "Two HTTP clients, single wildcard on sender" do
-    server 8000
-    http_client :A, ['/channels/name', '/channels/hello', '/channels/nested/hello']
-    http_client :B, []
-    publish :B, '/channels/*', 'msg' => 'hey'
-    check_inbox(
-        :A => {
-          '/channels/name' => ['msg' => 'hey'],
-          '/channels/hello' => ['msg' => 'hey']
-        },
-        :B => {}
-    )
-  end
-
-  scenario "Two HTTP clients, single wildcard on both" do
-    server 8000
-    http_client :A, ['/channels/*']
-    http_client :B, []
-    publish :B, '/channels/*', 'msg' => 'hey'
-    check_inbox(
-        :A => {
-          '/channels/*' => ['msg' => 'hey']
-        },
-        :B => {}
-    )
-  end
-
-  scenario "Two local clients, double wildcard on sender" do
-    server 8000
-    local_client :A, ['/channels/name', '/channels/hello', '/channels/nested/hello']
-    local_client :B, []
-    publish :B, '/channels/**', 'msg' => 'hey'
-    check_inbox(
-        :A => {
-          '/channels/name' => ['msg' => 'hey'],
-          '/channels/hello' => ['msg' => 'hey'],
-          '/channels/nested/hello' => ['msg' => 'hey']
-        },
-        :B => {}
-    )
-  end
-
-  scenario "Two local clients, one HTTP, double wildcard on sender and one subscription" do
-    server 8000
-    local_client :A, ['/channels/hello', '/channels/nested/hello']
-    local_client :B, []
-    http_client :C, ['/channels/name', '/channels/foo/**']
-    publish :B, '/channels/**', 'msg' => 'hey'
-    check_inbox(
-        :A => {
-          '/channels/hello' => ['msg' => 'hey'],
-          '/channels/nested/hello' => ['msg' => 'hey']
-        },
-        :B => {},
-        :C => {
-          '/channels/name' => ['msg' => 'hey'],
-          '/channels/foo/**' => ['msg' => 'hey']
-        }
-    )
-  end
-end
-