alondra 0.0.3

data/test/models/channel_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+module Alondra
+
+  class ChannelTest < ActiveSupport::TestCase
+
+    def setup
+      @connection = MockConnection.new
+    end
+
+    test "it has a name" do
+      channel   = Channel.new('test name channel')
+      assert_equal 'test name channel', channel.name
+    end
+
+    test "can fetch channel by name" do
+      channel = Channel['dummy channel']
+      assert_equal 'dummy channel', channel.name
+    end
+
+    test "allow clients to subscribe" do
+      channel   = Channel.new('test subscriptions channel')
+      assert_equal 0, channel.connections.size
+
+      channel.subscribe @connection
+
+      assert_equal 1, channel.connections.size
+      assert channel.connections.keys.include? @connection
+    end
+
+    test "deliver events to all subscribed connections" do
+      channel   = Channel.new('test deliver events channel')
+      channel.subscribe @connection
+
+      assert @connection.channels.include?(channel)
+
+      event = Event.new :event => :created, :resource => Chat.new, :channel => 'test deliver events channel'
+
+      channel.receive event
+
+      assert EM.reactor_running?
+
+      sleep(0.5) # Leave event machine to catch up
+
+      last_message = @connection.messages.last
+      assert_equal event.to_json, last_message
+    end
+  end
+end

data/test/models/command_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+module Alondra
+
+  class CommandTest < ActiveSupport::TestCase
+
+    def setup
+      @connection = MockConnection.new
+    end
+
+    test "it is created with a connection and a hash" do
+      command = Command.new @connection, :command => 'subscribe', :channel => 'test'
+
+      assert_equal :subscribe, command.name
+      assert_equal 'test', command.channel.name
+    end
+
+    test "subscribe to channel when subscribe command is executed" do
+      channel = Channel['test']
+      assert_equal 0, channel.connections.size
+
+      command = Command.new @connection, :command => 'subscribe', :channel => 'test'
+      command.execute!
+
+      assert_equal 1, channel.connections.size
+      assert channel.connections.keys.include? @connection
+    end
+  end
+end

data/test/models/configuration_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+module Alondra
+
+  class ConfigurationTest < ActiveSupport::TestCase
+
+    test "it has default values" do
+      assert_equal 12346, Alondra.config.port
+    end
+
+    test "it allows to override default values" do
+      assert_equal 'localhost', Alondra.config.host
+      Alondra.config.host    = 'www.example.com'
+      assert_equal 'www.example.com', Alondra.config.host
+    end
+
+    test "it allows to define new variables" do
+      Alondra.config.test_variable = 'something'
+      assert_equal 'something', Alondra.config.test_variable
+    end
+  end
+end

data/test/models/connection_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+module Alondra
+
+  class ConnectionTest < ActiveSupport::TestCase
+
+    test "it is assigned an UUI on creation" do
+      assert MockConnection.new.uuid.present?
+    end
+
+    test "can find if there is a session" do
+      session = {:user_id => 10}
+      connection = MockConnection.new(session)
+
+      assert_equal session, connection.session
+    end
+  end
+end

data/test/models/event_listener_test.rb

@@ -0,0 +1,217 @@
+require 'test_helper'
+
+module Alondra
+
+  class ChatListener < EventListener
+
+    def self.created_chat_ids
+      @created_chat_ids ||= []
+    end
+
+    def self.subscribed_user_ids
+      @subscribed_user_ids ||= []
+    end
+
+    def self.subscribed_to_collection
+      @subscribed_to_collection ||= []
+    end
+
+    def self.subscribed_to_member
+      @subscribed_to_member ||= []
+    end
+
+    def self.custom_events
+      @custom_events ||= []
+    end
+
+    on :created do |event|
+      ChatListener.created_chat_ids << event.resource.id
+    end
+
+    on :destroyed do |event|
+      chat = event.resource
+      ChatListener.created_chat_ids.delete(chat.id)
+    end
+
+    on :subscribed do |event|
+      ChatListener.subscribed_user_ids << session[:user_id]
+    end
+
+    on :unsubscribed do |event|
+      ChatListener.subscribed_user_ids.delete(session[:user_id])
+    end
+
+    on :subscribed, :to => :collection do |event|
+      ChatListener.subscribed_to_collection << session[:user_id]
+    end
+
+    on :unsubscribed, :to => :collection do |event|
+      ChatListener.subscribed_to_collection.delete(session[:user_id])
+    end
+
+    on :subscribed, :to => :member do |event|
+      ChatListener.subscribed_to_member << session[:user_id]
+    end
+
+    on :unsubscribed, :to => :member do |event|
+      ChatListener.subscribed_to_member.delete(session[:user_id])
+    end
+
+    on :custom do |event|
+      ChatListener.custom_events << event
+    end
+
+    on :boom do |event|
+      event.boom!
+    end
+
+  end
+
+
+  class EventListenerTest < ActiveSupport::TestCase
+
+    test "can listen to a specific channel providing a string pattern" do
+      class TextPatternListener < EventListener
+        listen_to 'string pattern'
+      end
+
+      assert  TextPatternListener.listen_to?('string pattern')
+      assert  TextPatternListener.listen_to?('string pattern and more')
+      assert !TextPatternListener.listen_to?('other string pattern')
+    end
+
+    test "can listen to specific channel providing a regexp as pattern" do
+      class RegexpPatternListener < EventListener
+        listen_to /man$/
+      end
+
+      assert  RegexpPatternListener.listen_to?('Superman')
+      assert !RegexpPatternListener.listen_to?('Lex Luthor')
+    end
+
+    test "it has a default channel pattern" do
+      class DefaultPatternsListener < EventListener; end
+
+      assert  DefaultPatternsListener.listen_to?('/default/patterns/')
+      assert  DefaultPatternsListener.listen_to?('/default/patterns/1')
+
+      assert !DefaultPatternsListener.listen_to?('/default/other/')
+      assert !DefaultPatternsListener.listen_to?('/other/patterns/')
+    end
+
+    test "default channel pattern is ignored if explicit listen_to pattern is called" do
+      class OverwrittenDefaultPatternsListener < EventListener
+        listen_to '/others'
+      end
+
+      assert  OverwrittenDefaultPatternsListener.listen_to?('/others')
+      assert  OverwrittenDefaultPatternsListener.listen_to?('/others/1/')
+      assert !OverwrittenDefaultPatternsListener.listen_to?('/overwritten/default/patterns')
+    end
+
+
+    test 'receive created and destroyes events' do
+      ChatListener.listen_to '/chats/'
+
+      chat = Chat.create(:name => 'Observed chat')
+
+      sleep(0.1)
+
+      assert ChatListener.created_chat_ids.include?(chat.id)
+
+      chat.destroy
+
+      sleep(0.1)
+
+      assert !ChatListener.created_chat_ids.include?(chat.id)
+    end
+
+    test 'react to subscribed and unsubscribed events' do
+      session = {:user_id => 28 }
+      connection = MockConnection.new(session)
+
+      assert !ChatListener.subscribed_user_ids.include?(28)
+
+      Command.new(connection, :command => 'subscribe', :channel => '/chats/').execute!
+
+      sleep(0.1)
+
+      assert ChatListener.subscribed_user_ids.include?(28)
+
+      Command.new(connection, :command => 'unsubscribe', :channel => '/chats/').execute!
+
+      sleep(0.1)
+
+      assert !ChatListener.subscribed_user_ids.include?(28)
+    end
+
+    test 'react to subscribed and unsubscribed events on collection' do
+      session = {:user_id => 29 }
+      connection = MockConnection.new(session)
+
+      assert !ChatListener.subscribed_to_collection.include?(29)
+      assert !ChatListener.subscribed_to_member.include?(29)
+
+      Command.new(connection, :command => 'subscribe', :channel => '/chats/').execute!
+
+      sleep(0.1)
+
+      assert ChatListener.subscribed_to_collection.include?(29)
+      assert !ChatListener.subscribed_to_member.include?(29)
+
+      Command.new(connection, :command => 'unsubscribe', :channel => '/chats/').execute!
+
+      sleep(0.1)
+
+      assert !ChatListener.subscribed_to_collection.include?(29)
+      assert !ChatListener.subscribed_to_member.include?(29)
+    end
+
+    test 'react to subscribed and unsubscribed events on member' do
+      session = {:user_id => 30 }
+      connection = MockConnection.new(session)
+
+      chat = Factory.create :chat
+
+      chat_channel = "/chats/#{chat.id}"
+
+      assert !ChatListener.subscribed_to_collection.include?(30)
+      assert !ChatListener.subscribed_to_member.include?(30)
+
+      Command.new(connection, :command => 'subscribe', :channel => chat_channel).execute!
+
+      sleep(0.1)
+
+      assert !ChatListener.subscribed_to_collection.include?(30)
+      assert ChatListener.subscribed_to_member.include?(30)
+
+      Command.new(connection, :command => 'unsubscribe', :channel => chat_channel).execute!
+
+      sleep(0.1)
+
+      assert !ChatListener.subscribed_to_collection.include?(30)
+      assert !ChatListener.subscribed_to_member.include?(30)
+    end
+
+    test 'receive customs events' do
+      event = Event.new :event => :custom, :resource => Chat.new, :channel => '/chats/'
+      EventRouter.new.process(event)
+
+      sleep(0.1)
+
+      assert_equal ChatListener.custom_events.last, event
+    end
+
+    test 'capture exceptions launched in event listener' do
+      boom = BogusEvent.new :event => :boom, :resource => Chat.new, :channel => '/chats/'
+      EventRouter.new.process(boom)
+
+      event = Event.new :event => :custom, :resource => Chat.new, :channel => '/chats/'
+      EventRouter.new.process(event)
+
+      sleep(0.1)
+
+      assert_equal ChatListener.custom_events.last, event
+    end
+  end
+end

data/test/models/event_router_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+module Alondra
+
+  class EventRouterTest < ActiveSupport::TestCase
+  end
+end

data/test/models/message_queue_client_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+module Alondra
+
+  class MessageQueueClientTest < ActiveSupport::TestCase
+
+    test "a sync client uses a sync zeromq context" do
+      context = SyncMessageQueueClient.new.send :context
+      assert context.class == ZMQ::Context
+    end
+
+    test "an async client uses an async zeromq context" do
+      context = nil
+
+      assert EM.reactor_running?
+
+      EM.schedule do
+        context = MessageQueueClient.instance.send :context
+      end
+
+      sleep(0.1)
+
+      assert context.class == EM::ZeroMQ::Context
+    end
+  end
+end

data/test/models/message_queue_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+module Alondra
+
+  class MessageQueueTest < ActiveSupport::TestCase
+    setup do
+      @original_event_router = MessageQueue.instance.send :event_router
+      @router = MockEventRouter.new
+
+      @chat = Chat.create(:name => 'Silly chat')
+
+      MessageQueue.instance.instance_variable_set :@event_router, @router
+      @event = Event.new :event => :custom, :resource => @chat, :channel => '/chats/'
+    end
+
+    teardown do
+      MessageQueue.instance.instance_variable_set :@event_router, @original_event_router
+    end
+
+    test "a message pushed asynchronously to the queue is received by the event router" do
+      assert MessageQueueClient.instance.class == AsyncMessageQueueClient
+
+      MessageQueueClient.push @event
+
+      sleep(0.1)
+
+      assert received(@event)
+    end
+
+    test "a message pushed synchronously to the queue is received by the event router" do
+
+      client = MessageQueueClient.sync_instance
+      context = client.send :context
+      assert context.class == ZMQ::Context
+
+      client.send_message(@event)
+
+      sleep(0.1)
+
+      assert received(@event)
+    end
+
+    test "message queue still works when an exception is thrown while processing an event" do
+      3.times do
+        bogus = BogusEvent.new :event => :custom, :resource => @chat, :channel => '/chats/'
+
+        begin
+          MessageQueueClient.push bogus
+        rescue BogusException
+          puts "rescued exception"
+        end
+      end
+
+      MessageQueueClient.push @event
+
+      sleep(0.1)
+
+      assert received(@event)
+    end
+
+    def received(event)
+      @router.received_events.find do |matching_event|
+        matching_event.type == event.type &&
+        matching_event.resource_type == event.resource_type &&
+        matching_event.resource.id == event.resource.id &&
+        matching_event.channel_name == event.channel_name
+      end
+    end
+  end
+end

data/test/models/pushing_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+module Alondra
+
+  class PushingTest < ActiveSupport::TestCase
+
+    test "publish created events to the specified channel" do
+      chat       = Factory.create :chat
+      connection = MockConnection.new
+      message = chat.messages.build(:text => 'test message')
+
+      channel_name = Channel.default_name_for(chat)
+      assert channel_name =~ /chats\/\d+/
+
+      channel    = Channel[channel_name]
+      channel.subscribe connection
+
+      sleep(0.1)
+
+      message.save!
+
+      sleep(0.1)
+
+      assert connection.messages.last, "should publish a message"
+
+      last_event = ActiveSupport::JSON.decode(connection.messages.last)
+      resource   = last_event['resource']
+
+      assert_equal 'created', last_event['event']
+      assert_equal 'Message', last_event['resource_type']
+      assert_equal message.id, resource['id']
+    end
+  end
+end

data/test/performance/message_queue_performance.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+module Alondra
+
+  class MessageQueuePerformanceTest < ActiveSupport::TestCase
+
+    NUM_MESSAGES = 1_000
+
+    setup do
+      @event = Event.new :event => :custom, :resource => Chat.new, :channel => '/chats/'
+
+      # Initialize queue
+      MessageQueueClient.push @event
+
+      @original_event_router = MessageQueue.instance.send :event_router
+      @router = MockEventRouter.new
+
+      MessageQueue.instance.instance_variable_set :@event_router, @router
+    end
+
+    teardown do
+      MessageQueue.instance.instance_variable_set :@event_router, @original_event_router
+    end
+
+    test "message queue performance" do
+      puts "send #{NUM_MESSAGES} messages to queue"
+
+      time = Benchmark.measure do
+        NUM_MESSAGES.times do
+          MessageQueueClient.async_instance.send_message @event
+        end
+
+        while @router.received_events.size < NUM_MESSAGES
+          sleep(0.1)
+        end
+      end
+
+      events_per_second = NUM_MESSAGES/time.total
+
+      puts "aprox. received events per second #{events_per_second}"
+
+      assert events_per_second >= 500
+    end
+
+
+    test "message queue performance with sync client" do
+      puts "send #{NUM_MESSAGES} messages to queue"
+
+      time = Benchmark.measure do
+        NUM_MESSAGES.times do
+          MessageQueueClient.sync_instance.send_message @event
+        end
+
+        while @router.received_events.size < NUM_MESSAGES
+          sleep(0.1)
+        end
+      end
+
+      events_per_second = NUM_MESSAGES/time.total
+
+      puts "aprox. received events per second #{events_per_second}"
+
+      assert events_per_second >= 500
+    end
+  end
+end

data/test/support/factories.rb

@@ -0,0 +1,19 @@
+Factory.define :chat do |f|
+  f.name 'Test chat'
+end
+
+Factory.define :message do |f|
+  f.association :chat
+  f.text 'Test message'
+end
+
+Factory.sequence :username do |i|
+  "user#{i}"
+end
+
+Factory.define :user do |f|
+  f.username { Factory.next(:username) }
+  f.email    { |u| "#{u.username}@example.com" }
+  f.password 'secret'
+  f.password_confirmation 'secret'
+end

data/test/support/integration_helper.rb

@@ -0,0 +1,18 @@
+module Alondra
+  module IntegrationHelper
+    def login_as(user)
+      visit new_session_path
+      fill_in "login", :with => user.username
+      fill_in "password", :with => "secret"
+      click_button "Log in"
+    end
+
+    def log_out
+      click_link _('logout')
+    end
+
+    def clean_db
+      [User, Chat, ::Message].each { |model| model.delete_all }
+    end
+  end
+end

data/test/support/integration_test.rb

@@ -0,0 +1,6 @@
+# Define a bare test case to use with Capybara
+class ActiveSupport::IntegrationCase < ActiveSupport::TestCase
+  include Capybara::DSL
+  include Rails.application.routes.url_helpers
+  include Alondra::IntegrationHelper
+end

data/test/support/mocks/bogus_event.rb

@@ -0,0 +1,15 @@
+module Alondra
+
+  class BogusException < StandardError; end
+
+  class BogusEvent < Event
+
+    def to_json
+      boom!
+    end
+
+    def boom!
+      raise BogusException.new("Ha ha ha, I'm evil!")
+    end
+  end
+end

data/test/support/mocks/mock_connection.rb

@@ -0,0 +1,24 @@
+module Alondra
+  class MockConnection < Connection
+
+    def initialize(session = {})
+      super UUIDTools::UUID.random_create, session
+    end
+
+    def send(message)
+      messages << message
+    end
+
+    def receive(event)
+      messages << event.to_json
+    end
+
+    def channels
+      @channels ||= []
+    end
+
+    def messages
+      @messages ||= []
+    end
+  end
+end

data/test/support/mocks/mock_event_router.rb

@@ -0,0 +1,12 @@
+module Alondra
+  class MockEventRouter
+
+    def process(event)
+      received_events << event
+    end
+
+    def received_events
+      @received_events ||= []
+    end
+  end
+end

data/test/support/mocks/mock_listener.rb

@@ -0,0 +1,9 @@
+class MockListener
+  def received_events
+    @received_events ||= []
+  end
+
+  def receive(event)
+    received_events << event
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+# Configure Rails Environment
+ENV["RAILS_ENV"]    = "test"
+ENV["ALONDRA_SERVER"] = 'true'
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rails/test_help"
+require 'capybara/rails'
+
+Alondra::Alondra.start_server_in_new_thread!
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }