tochtli 0.5.0

data/test/controller_manager_test.rb

@@ -0,0 +1,75 @@
+require_relative 'test_helper'
+
+Thread.abort_on_exception = true
+
+class ControllerManagerTest < Minitest::Test
+  include Tochtli::Test::Helpers
+  
+  class FirstController < Tochtli::BaseController
+  end
+
+  class SecondController < Tochtli::BaseController
+  end
+
+  class ThirdController < Tochtli::BaseController
+  end
+
+  def setup
+    @logger       = Logger.new(STDERR)
+    @logger.level = Logger::WARN
+  end
+
+  def teardown
+    Tochtli::ControllerManager.stop
+  end
+
+  def test_start_single_controller
+    Tochtli::ControllerManager.start(FirstController, connection: @connection, logger: @logger)
+    assert FirstController.started?
+    refute SecondController.started?
+    refute ThirdController.started?
+  end
+
+  def test_start_selected_controllers
+    Tochtli::ControllerManager.start(FirstController, ThirdController, connection: @connection, logger: @logger)
+    assert FirstController.started?
+    refute SecondController.started?
+    assert ThirdController.started?
+  end
+
+  def test_start_all_controllers
+    Tochtli::ControllerManager.start(:all, connection: @connection, logger: @logger)
+    assert FirstController.started?
+    assert SecondController.started?
+    assert ThirdController.started?
+  end
+
+  def test_restart_only_active_controllers
+    Tochtli::ControllerManager.start(FirstController, SecondController, connection: @connection, logger: @logger)
+    Tochtli::ControllerManager.restart(connection: @connection, logger: @logger)
+    assert FirstController.started?
+    assert SecondController.started?
+    refute ThirdController.started?
+  end
+
+  def test_state_monitor
+    Tochtli::ControllerManager.start(FirstController, connection: @connection, logger: @logger)
+  end
+
+	def test_multiple_queues
+		Tochtli::ControllerManager.setup(connection: @connection, logger: @logger)
+		Tochtli::ControllerManager.start(FirstController, queue_name: 'first_queue')
+		Tochtli::ControllerManager.start(FirstController, queue_name: 'second_queue')
+
+		assert_equal ["first_queue", "second_queue"], FirstController.dispatcher.queues.map(&:name).sort
+	end
+
+	def test_restart_multiple_queues
+		Tochtli::ControllerManager.setup(connection: @connection, logger: @logger)
+		Tochtli::ControllerManager.start(FirstController, queue_name: 'first_queue')
+		Tochtli::ControllerManager.start(FirstController, queue_name: 'second_queue')
+		Tochtli::ControllerManager.restart
+
+		assert_equal ["first_queue", "second_queue"], FirstController.dispatcher.queues.map(&:name).sort
+	end
+end

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/config/application.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+Bundler.require
+
+require 'tochtli'
+
+module Dummy
+  class Application < Rails::Application
+    # Set dummy app root
+    config.root = File.expand_path('../..', __FILE__)
+
+    config.eager_load                                  = false
+    config.encoding                                    = "utf-8"
+    config.filter_parameters                           += [:password]
+    config.active_support.escape_html_entities_in_json = true
+    config.active_record.schema_format                 = :sql
+    config.assets.enabled                              = true
+    config.assets.version                              = '1.0'
+    config.cache_classes                               = true
+    config.serve_static_files                          = true
+    config.static_cache_control                        = "public, max-age=3600"
+    config.whiny_nils                                  = true
+    config.consider_all_requests_local                 = true
+    config.action_controller.perform_caching           = false
+    config.action_dispatch.show_exceptions             = false
+    config.action_controller.allow_forgery_protection  = false
+    config.action_mailer.delivery_method               = :test
+    config.active_support.deprecation                  = :stderr
+    config.secret_token                                = 'efc39d860d9d26146e6546fc69b12c014f98785e08a8099174583af0a04a27774604060f591678aef27c491f9d00792a00884a92bb35e4ca122d0cbeddd4ea98'
+    config.active_support.test_order                   = :random
+  end
+end
+
+

data/test/dummy/config/boot.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+
+ENV['BUNDLE_GEMFILE'] = File.expand_path('../../../../Gemfile', __FILE__)
+require 'bundler/setup'

data/test/dummy/config/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: db/test.sqlite3

data/test/dummy/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the rails application
+require File.expand_path('../application', __FILE__)
+
+# Initialize the rails application
+Dummy::Application.initialize!

data/test/dummy/config/rabbit.yml

@@ -0,0 +1,4 @@
+test:
+  host: 127.0.0.1
+  user: guest
+  password: guest

data/test/key_matcher_test.rb

@@ -0,0 +1,100 @@
+require_relative 'test_helper'
+require 'benchmark'
+
+class MessageTest < Minitest::Test
+	KeyPattern = Tochtli::BaseController::KeyPattern
+
+	def test_simple_pattern
+		pattern = KeyPattern.new('a.b.c')
+
+		assert_matches pattern, 'a.b.c'
+		refute_matches pattern, 'a.b.c.d'
+		refute_matches pattern, 'b.c.d'
+	end
+
+	def test_asterix_at_start
+		pattern = KeyPattern.new('*.b.c')
+
+		assert_matches pattern, 'a.b.c'
+		assert_matches pattern, 'b.b.c'
+		refute_matches pattern, 'a.b.c.d'
+	end
+
+	def test_asterix_in_the_middle
+		pattern = KeyPattern.new('a.*.b.c')
+
+		assert_matches pattern, 'a.a.b.c'
+		assert_matches pattern, 'a.d.b.c'
+		refute_matches pattern, 'a.b.c.d'
+	end
+
+	def test_asterix_at_the_end
+		pattern = KeyPattern.new('a.b.c.*')
+
+		assert_matches pattern, 'a.b.c.d'
+		assert_matches pattern, 'a.b.c.a'
+		refute_matches pattern, 'a.b.c'
+		refute_matches pattern, 'a.b.c.d.e'
+	end
+
+	def test_hash
+		pattern = KeyPattern.new('#')
+
+		assert_matches pattern, ''
+		assert_matches pattern, 'a.b.c'
+		assert_matches pattern, 'a.b.b.c'
+	end
+
+	def test_hash_at_start
+		pattern = KeyPattern.new('#.b.c')
+
+		assert_matches pattern, 'b.c'
+		assert_matches pattern, 'a.b.c'
+		assert_matches pattern, 'a.b.b.c'
+		refute_matches pattern, 'a.b.c.d'
+	end
+
+	def test_hash_in_the_middle
+		pattern = KeyPattern.new('a.#.c')
+
+		assert_matches pattern, 'a.a.b.c'
+		assert_matches pattern, 'a.d.b.c'
+		refute_matches pattern, 'a.b.c.d'
+	end
+
+	def test_hash_at_the_end
+		pattern = KeyPattern.new('a.b.#')
+
+		assert_matches pattern, 'a.b.c.d'
+		assert_matches pattern, 'a.b.c'
+		assert_matches pattern, 'a.b.c.d.e'
+	end
+
+	def test_complex
+		pattern = KeyPattern.new('*.*.a.b.#.c.#')
+
+		assert_matches pattern, '1.2.a.b.c.d'
+		assert_matches pattern, '1.2.a.b.3.4.c.d'
+		assert_matches pattern, '1.2.a.b.c'
+		refute_matches pattern, 'a.b.c.d.e'
+	end
+
+	def test_performance
+		pattern = KeyPattern.new('*.*.a.b.#.c.#')
+
+		n = 10_000
+		time = Benchmark.realtime { n.times { pattern =~ '1.2.a.b.3.4.c.d' } }
+
+		assert time < 0.1
+	end
+
+	protected
+
+	def assert_matches(pattern, key)
+		assert pattern =~ key, "#{key} SHOULD match #{pattern}"
+	end
+
+	def refute_matches(pattern, key)
+		assert pattern !~ key, "#{key} MUST NOT match #{pattern}"
+	end
+end

data/test/message_test.rb

@@ -0,0 +1,80 @@
+require_relative 'test_helper'
+
+class MessageTest < Minitest::Test
+  include Tochtli::Test::Helpers
+  
+  class SimpleMessage < Tochtli::Message
+    route_to 'test.controller.simple'
+
+    attribute :text, String
+    attribute :timestamp, Time
+    attribute :optional, String, required: false
+
+    def validate
+      setup_timestamp
+      unless optional.nil? || optional =~ /\A[a-z!]+\z/i
+        add_error "Invalid optional attribute: #{optional}"
+      end
+      super
+    end
+
+    def setup_timestamp
+      @timestamp ||= Time.now
+    end
+  end
+
+  class OpenMessage < Tochtli::Message
+    ignore_extra_attributes
+
+    attribute :text, String
+  end
+
+  def test_routing_key
+    assert_equal 'test.controller.simple', SimpleMessage.routing_key
+  end
+
+  def test_simple_message_without_optional
+    message = SimpleMessage.new(text: 'Hello')
+    assert_equal 'Hello', message.text
+    assert_nil message.optional
+    assert message.valid?
+  end
+
+  def test_simple_message_with_optional
+    message = SimpleMessage.new(text: 'Hello', optional: 'world!')
+    assert_equal 'Hello', message.text
+    assert_equal 'world!', message.optional
+    assert message.valid?
+  end
+
+  def test_invalid_attribute
+    message = SimpleMessage.new(text: 'Hello', optional: 'world 123')
+    assert message.invalid?, "Message passed validation when it should not"
+    assert_equal "Invalid optional attribute: world 123", message.errors[0]
+  end
+
+  def test_validation_callback_without_value
+    message = SimpleMessage.new(text: 'Hello')
+    assert message.valid?
+    assert_kind_of Time, message.timestamp
+  end
+
+  def test_validation_callbacks_with_given_value
+    timestamp = Time.at(0) # long long ago
+    message   = SimpleMessage.new(text: 'Hello', timestamp: timestamp)
+    assert message.valid?
+    assert_equal timestamp, message.timestamp
+  end
+
+  def test_undefined_attribute_error
+    message = SimpleMessage.new(text: 'Hello', extra: 'from Paris')
+    assert message.invalid? # Undefined attribute :extra
+    assert_equal "Unexpected attributes: extra", message.errors[0]
+  end
+
+  def test_ignore_excess_attribute
+    message = OpenMessage.new(text: 'Hello', extra: 'from Paris')
+    assert message.valid?
+  end
+
+end

data/test/rabbit_client_test.rb

@@ -0,0 +1,71 @@
+require_relative 'test_helper'
+
+class RabbitClientTest < Minitest::Test
+  include Tochtli::Test::Client
+  
+  def test_reply_queue
+    reply_queue = @client.reply_queue
+    assert_kind_of Tochtli::ReplyQueue, reply_queue
+    assert_equal @client.rabbit_connection, reply_queue.connection
+    refute_nil reply_queue.name
+  end
+
+  def test_publishing
+    @client.publish FakeMessage.new(test_attr: 'test')
+
+    assert_published FakeMessage, test_attr: 'test'
+  end
+
+  def test_reply
+    handler = Tochtli::Test::TestMessageHandler.new
+
+    message = FakeMessage.new(test_attr: 'test')
+    @client.publish message, handler: handler
+
+    expected_reply = handle_reply(FakeReply, message, result: 'test123')
+
+    assert_equal expected_reply, handler.reply
+  end
+
+  def test_reply_timeout
+    handler = Tochtli::Test::TestMessageHandler.new
+    message = FakeMessage.new(test_attr: 'test')
+    @client.publish message, handler: handler, timeout: 0.05
+    sleep 0.1
+    assert_equal message, handler.timeout_message
+  end
+
+  def test_reply_no_timeout
+    handler = Tochtli::Test::TestMessageHandler.new
+    message = FakeMessage.new(test_attr: 'test')
+    @client.publish message, handler: handler, timeout: 0.1
+
+    expected_reply = create_reply(FakeReply, message, result: 'test123')
+    @client.reply_queue.handle_reply expected_reply
+
+    sleep 0.2
+
+    assert_equal expected_reply, handler.reply
+    assert_nil handler.timeout_message
+  end
+
+  def test_message_drop
+    handler = Tochtli::Test::TestMessageHandler.new
+    message = FakeMessage.new(test_attr: 'test')
+    @client.publish message, handler: handler, timeout: 0.1
+    @client.reply_queue.handle_reply Tochtli::MessageDropped.new("Message dropped", message), message.id
+
+    assert_kind_of Tochtli::MessageDropped, handler.error
+  end
+
+  class FakeMessage < Tochtli::Message
+    route_to 'test.fake.topic'
+
+    attributes :test_attr
+  end
+
+  class FakeReply < Tochtli::Message
+    attributes :result
+  end
+
+end

data/test/rabbit_connection_test.rb

@@ -0,0 +1,151 @@
+require_relative 'test_helper'
+require 'tochtli/test/test_case'
+
+class RabbitConnectionTest < Minitest::Test
+  def setup
+    Tochtli::RabbitConnection.close('test')
+  end
+
+  def teardown
+    Tochtli::RabbitConnection.close('test')
+  end
+
+  class TestMessage < Tochtli::Message
+    attributes :text
+  end
+
+  def test_connection_with_default_options
+    Tochtli::RabbitConnection.open('test') do |connection|
+      assert_equal "puzzleflow.services", connection.exchange.name
+    end
+  end
+
+  def test_connection_with_custom_options
+    Tochtli::RabbitConnection.open('test', exchange_name: "puzzleflow.tests") do |connection|
+      assert_equal "puzzleflow.tests", connection.exchange.name
+    end
+  end
+
+  def test_multiple_channels_and_exchanges
+    Tochtli::RabbitConnection.open('test', exchange_name: "puzzleflow.tests") do |connection|
+      another_thread = Thread.new {}
+
+      current_channel = connection.channel
+      another_channel = connection.channel(another_thread)
+
+      current_exchange = connection.exchange
+      another_exchange = connection.exchange(another_thread)
+
+      refute_equal current_channel, another_channel
+      refute_equal current_exchange, another_exchange
+      assert_equal "puzzleflow.tests", current_exchange.name
+      assert_equal "puzzleflow.tests", another_exchange.name
+    end
+  end
+
+  def test_queue_creation_and_existance
+    Tochtli::RabbitConnection.open('test') do |connection|
+      queue = connection.queue('test-queue', [], auto_delete: true)
+      refute_nil queue
+      assert_equal 'test-queue', queue.name
+      assert connection.queue_exists?('test-queue')
+    end
+  end
+
+  def test_reply_queue_recovery
+    Tochtli::RabbitConnection.open('test',
+                                   network_recovery_interval:     0.1,
+                                   recover_from_connection_close: true) do |rabbit_connection|
+      reply_queue   = rabbit_connection.reply_queue
+      original_name = reply_queue.name
+      timeout       = 0.3
+
+      message = TestMessage.new(text: "Response")
+      reply   = TestMessage.new(text: "Reply")
+      handler = Tochtli::Test::TestMessageHandler.new
+      reply_queue.register_message_handler message, handler, timeout
+
+      rabbit_connection.publish reply_queue.name, reply, correlation_id: message.id, timeout: timeout
+      sleep timeout
+
+      refute_nil handler.reply
+
+      # simulate network failure
+      rabbit_connection.connection.handle_network_failure(RuntimeError.new('fake connection error'))
+      sleep 0.1 until rabbit_connection.open? # wait for recovery
+      refute_equal original_name, reply_queue.name, "Recovered queue should have re-generated name"
+
+      message = TestMessage.new(text: "Response")
+      reply   = TestMessage.new(text: "Reply")
+      handler = Tochtli::Test::TestMessageHandler.new
+      reply_queue.register_message_handler message, handler, timeout
+
+      rabbit_connection.publish reply_queue.name, reply, correlation_id: message.id, timeout: timeout
+      sleep timeout
+
+      refute_nil handler.reply
+    end
+  end
+
+  def test_multithreaded_consumer_performance
+    work_pool_size = 10
+    Tochtli::RabbitConnection.open('test',
+                                   exchange_name:  "puzzleflow.tests",
+                                   work_pool_size: work_pool_size) do |connection|
+      mutex                  = Mutex.new
+      cv                     = ConditionVariable.new
+      thread_count           = 5
+      message_count          = 100
+      expected_message_count = message_count*thread_count
+
+      consumed         = 0
+      consumed_mutex   = Mutex.new
+      consumer_threads = Set.new
+      consumer         = Proc.new do |delivery_info, metadata, payload|
+        consumed_mutex.synchronize { consumed += 1 }
+        consumer_threads << Thread.current
+        connection.publish metadata.reply_to, TestMessage.new(text: "Response to #{payload}")
+      end
+
+      queue = connection.channel.queue('', auto_delete: true)
+      queue.bind(connection.exchange, routing_key: queue.name)
+      queue.subscribe(block: false, &consumer)
+
+      replies        = 0
+      reply_consumer = Proc.new do |delivery_info, metadata, payload|
+        replies += 1
+        mutex.synchronize { cv.signal } if replies == expected_message_count
+      end
+
+      reply_queue = connection.channel.queue('', auto_delete: true)
+      reply_queue.bind(connection.exchange, routing_key: reply_queue.name)
+      reply_queue.subscribe(block: false, &reply_consumer)
+
+      start_t = Time.now
+
+      threads = (1..thread_count).collect do
+        t                    = Thread.new do
+          message_count.times do |i|
+            connection.publish queue.name, TestMessage.new(text: "Message #{i}"),
+                               reply_to: reply_queue.name
+          end
+        end
+        t.abort_on_exception = true
+        t
+      end
+
+      threads.each(&:join)
+
+      mutex.synchronize { cv.wait(mutex, 5.0) }
+
+      end_t = Time.now
+      time  = end_t - start_t
+
+      assert_equal expected_message_count, consumed
+      assert_equal expected_message_count, replies
+      assert_equal work_pool_size, consumer_threads.size
+
+      puts "Published: #{expected_message_count} in #{time} (#{expected_message_count/time}req/s)"
+    end
+  end
+end