euston-daemons 1.0.5 → 1.2.1

data/lib/euston-daemons/rake_tasks.rb

@@ -1,7 +1,5 @@
 require 'euston-daemons'
-require 'rake/tasklib'
 
-require_rel 'rake_task.rb'
-require_rel 'command_processor_daemon/rake_task.rb'
-require_rel 'event_processor_daemon/rake_task.rb'
-require_rel 'message_buffer_daemon/rake_task.rb'
+require 'rake/tasklib'
+require 'euston-daemons/rake_task'
+require 'euston-daemons/pipeline/rake_task'

data/lib/euston-daemons/version.rb

@@ -1,5 +1,5 @@
 module Euston
   module Daemons
-    VERSION = "1.0.5"
+    VERSION = "1.2.1"
   end
 end

data/spec/daemons/command_processor_spec.rb

@@ -0,0 +1,48 @@
+describe 'command handler component', :purge_event_store, :purge_rabbitmq do
+  require 'euston-daemons/pipeline/lib/command_processor/component'
+
+  let(:logger)            { Euston::NullLogger.instance }
+  let(:handlers)          { [] }
+  let(:subscription)      { StubRetryingSubscription.new }
+  let(:client)            { Euston::Daemons::Pipeline::CommandProcessor::Component.new @channel, handlers, 1, logger }
+  let(:aggregate)         { Euston::Daemons::SampleModel::Counter2.new }
+  let(:saved_aggregates)  { [] }
+
+  before do
+    Euston::RabbitMq::RetryingSubscription.stub(:new) { subscription }
+    Euston::Repository.stub(:find) { aggregate }
+    Euston::Repository.stub(:save) { |aggregate| saved_aggregates << aggregate }
+  end
+
+  context 'a message is received' do
+    before do
+      client.run
+      command = Factory.build(:create_counter_command, :id => Uuid.generate).to_hash
+      subscription.stub_message_receipt command
+    end
+
+    context 'the message is not explicitly handled by a command handler class' do
+      subject { saved_aggregates }
+      it { should_not be_empty }
+    end
+
+    context 'the message is explicitly handled by a command handler class' do
+      class CreateCounter
+        include Euston::CommandHandler
+
+        class << self
+          attr_accessor :was_called
+        end
+
+        version 1 do |headers, command|
+          self.class.was_called = true
+        end
+      end
+
+      let(:handlers) { [ Euston::RabbitMq::HandlerReference.new(Object, CreateCounter, :CreateCounter) ] }
+
+      subject { CreateCounter.was_called }
+      it { should be_true }
+    end
+  end
+end

data/spec/daemons/event_processor_spec.rb

@@ -0,0 +1,55 @@
+describe 'event handler client', :purge_event_store, :purge_rabbitmq do
+  require 'euston-daemons/pipeline/lib/event_processor/component'
+
+  let(:logger)            { Euston::NullLogger.instance }
+  let(:subscription)      { StubRetryingSubscription.new }
+  let(:client)            { Euston::Daemons::Pipeline::EventProcessor::Component.new @channel, reference, 1, logger }
+  let(:aggregate)         { Euston::Daemons::SampleModel::Counter2.new }
+  let(:saved_aggregates)  { [] }
+
+  before do
+    Euston::RabbitMq::RetryingSubscription.stub(:new) { subscription }
+    Euston::Repository.stub(:find) { aggregate }
+    Euston::Repository.stub(:save) { |aggregate| saved_aggregates << aggregate }
+  end
+
+  context 'a message is received' do
+    before do
+      client.run
+
+      event = { :headers => { :id => Uuid.generate,
+                              :type => :external_thing_happened,
+                              :timestamp => Time.now.to_f,
+                              :version => 1 },
+                :body => {} }
+
+      subscription.stub_message_receipt event
+    end
+
+    context 'the event handler is bound to an aggregate root' do
+      let(:reference) { Euston::RabbitMq::HandlerReference.new(Euston::Daemons::SampleModel, Euston::Daemons::SampleModel::Counter2, :Counter2) }
+
+      subject { saved_aggregates }
+      it { should_not be_empty }
+    end
+
+    context 'the message is explicitly handled by an event handler class' do
+      class ExternalThingHappenedListener
+        include Euston::EventHandler
+
+        class << self
+          attr_accessor :was_called
+        end
+
+        subscribes :external_thing_happened, do |headers, command|
+          self.class.was_called = true
+        end
+      end
+
+      let(:reference) { Euston::RabbitMq::HandlerReference.new(Object, ExternalThingHappenedListener, :ExternalThingHappenedListener) }
+
+      subject { ExternalThingHappenedListener.was_called }
+      it { should be_true }
+    end
+  end
+end

data/spec/daemons/message_buffer_spec.rb

@@ -0,0 +1,106 @@
+describe 'message buffer component', :purge_event_store do
+  require 'euston-daemons/pipeline/lib/message_buffer/buffer'
+  require 'euston-daemons/pipeline/lib/message_buffer/component'
+
+  let(:logger)      { Euston::NullLogger.instance }
+  let(:channel)     { double('channel').as_null_object }
+  let(:command)     { Factory.build(:create_counter_command, :id => Uuid.generate).to_hash }
+  let(:exchange)    { double('exchange').as_null_object }
+  let(:published)   { [] }
+  let(:collection)  { @event_store_database[buffer.name] }
+  let(:buffer)      { Euston::Daemons::Pipeline::MessageBuffer::Buffer.new @event_store_database }
+  let(:component)   { Euston::Daemons::Pipeline::MessageBuffer::Component.new channel }
+
+  module Euston
+    class DaemonEnvironment
+      class << self
+        attr_accessor :event_store_mongodb
+      end
+    end
+  end
+
+  before do
+    Euston::DaemonEnvironment.event_store_mongodb = @event_store_database
+    channel.stub(:topic) { exchange }
+    exchange.stub(:name) { 'commands' }
+    exchange.stub(:publish) { |json, options| published << { :json => json, :options => options } }
+  end
+
+  context 'there are no commands in the buffer' do
+    describe 'command buffer size' do
+      subject { collection.count }
+      it      { should == 0 }
+    end
+
+    context 'the component runs' do
+      before { component.run }
+
+      describe 'published commands' do
+        subject { published }
+        it      { should be_empty }
+      end
+    end
+  end
+
+  context 'there is a due command' do
+
+    before do
+      buffer.enqueue :commands, command
+    end
+
+    describe 'command buffer size' do
+      subject { collection.count }
+      it      { should == 1 }
+    end
+
+    context 'the component runs' do
+      before { component.run }
+
+      describe 'published commands' do
+        subject { published }
+        it      { should have(1).item }
+      end
+
+      describe 'published command' do
+        subject       { published.first }
+        its([:json])  { should == command.to_json }
+      end
+
+      describe 'buffered command' do
+        subject { collection.count }
+        it      { should == 0 }
+      end
+    end
+  end
+
+  context 'there is a command that is not yet due' do
+    before do
+      buffer.enqueue :commands, command
+      collection.update({}, { '$set' => { 'dispatch_at' => Time.now.to_f + 1000 } }, { :safe => true })
+    end
+
+    context 'the component runs' do
+      before { component.run }
+
+      describe 'published commands' do
+        subject { published }
+        it      { should be_empty }
+      end
+    end
+  end
+
+  context 'a command is buffered for dispatch in the future' do
+    before do
+      buffer.enqueue :commands, command, Time.now.to_f + 1000
+    end
+
+    context 'the component runs' do
+      before { component.run }
+
+      describe 'published commands' do
+        subject { published }
+        it      { should be_empty }
+      end
+    end
+  end
+end

data/spec/daemons/snapshotter_spec.rb

@@ -0,0 +1,96 @@
+describe 'snapshotter component', :purge_event_store, :euston_event_store do
+  require 'euston-daemons/pipeline/lib/snapshotter/component'
+
+  let(:logger)      { Euston::NullLogger.instance }
+  let(:threshold)   { 2 }
+  let(:snapshotter) { Euston::Daemons::Pipeline::Snapshotter::Component.new @event_store, threshold, logger }
+  let(:commands)    { [] }
+  let(:counter_id)  { Uuid.generate }
+
+  def publish_commands_then_take_snapshot commands
+    commands.each { |c| publish_command c }
+    sleep 0.25        # to allow the async stream head update to finish
+    snapshotter.run
+  end
+
+  before { publish_commands_then_take_snapshot commands }
+
+  context 'there are no streams' do
+    describe 'snapshots collection size' do
+      subject { @event_store_database['snapshots'].count }
+      it { should == 0 }
+    end
+  end
+
+  context 'there is a stream that is too small to snapshot' do
+    let(:commands) { [ Factory.build(:create_counter_command) ] }
+
+    describe 'snapshots collection size' do
+      subject { @event_store_database['snapshots'].count }
+      it      { should == 0 }
+    end
+  end
+
+  context 'there is a stream that is large enough to snapshot' do
+    let(:commands)   { [ Factory.build(:create_counter_command, :id => counter_id),
+                         Factory.build(:increment_counter_command, :counter_id => counter_id, :amount => 1),
+                         Factory.build(:increment_counter_command, :counter_id => counter_id, :amount => 2) ] }
+
+    describe 'snapshots collection size' do
+      subject { @event_store_database['snapshots'].count }
+      it      { should == 1 }
+    end
+
+    describe 'snapshot' do
+      subject { @event_store.get_snapshot counter_id }
+      its(:headers) { should == { :version => 1 } }
+      its(:payload) { should == { :count   => 3 } }
+    end
+
+    describe 'reloading from the snapshot' do
+      subject               { Euston::Repository.find Euston::Daemons::SampleModel::Counter, counter_id }
+      its(:count)           { should == 3 }
+      its(:snapshot_loaded) { should == { :count => 3 }}
+    end
+  end
+
+  context 'multiple snapshots taken over time' do
+    let(:commands)  { [ Factory.build(:create_counter_command, :id => counter_id),
+                        Factory.build(:increment_counter_command, :counter_id => counter_id, :amount => 1),
+                        Factory.build(:increment_counter_command, :counter_id => counter_id, :amount => 2) ] }
+    let(:commands2) { [ Factory.build(:increment_counter_command, :counter_id => counter_id, :amount => 3),
+                        Factory.build(:increment_counter_command, :counter_id => counter_id, :amount => 5),
+                        Factory.build(:increment_counter_command, :counter_id => counter_id, :amount => 8) ] }
+    let(:commands3) { [ Factory.build(:increment_counter_command, :counter_id => counter_id, :amount => 13),
+                        Factory.build(:increment_counter_command, :counter_id => counter_id, :amount => 21),
+                        Factory.build(:increment_counter_command, :counter_id => counter_id, :amount => 34) ] }
+
+    before do
+      publish_commands_then_take_snapshot commands2
+      publish_commands_then_take_snapshot commands3
+    end
+
+    describe 'snapshots collection size' do
+      subject { @event_store_database['snapshots'].count }
+      it      { should == 3 }
+    end
+
+    describe 'first snapshot' do
+      subject { @event_store.get_snapshot counter_id, 3 }
+      its(:headers) { should == { :version => 1 } }
+      its(:payload) { should == { :count   => 3 } }
+    end
+
+    describe 'second snapshot' do
+      subject { @event_store.get_snapshot counter_id, 6 }
+      its(:headers) { should == { :version => 1 } }
+      its(:payload) { should == { :count   => 19 } }
+    end
+
+    describe 'third snapshot' do
+      subject { @event_store.get_snapshot counter_id }
+      its(:headers) { should == { :version => 1 } }
+      its(:payload) { should == { :count   => 87 } }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,91 @@
+jruby = RUBY_PLATFORM.to_s == 'java'
+
+require 'ap'
+require 'rabbitmqadmin-cli'
+require 'euston'
+require 'euston-rabbitmq'
+require 'euston-eventstore'
+require 'euston-daemons'
+require 'cranky'
+require 'ffaker'
+require 'mongo' unless jruby
+require 'jmongo' if jruby
+require 'hot_bunnies' if jruby
+require 'safely'
+
+specs_path = File.dirname __FILE__
+require File.join specs_path, 'support', 'factories', 'event_message'
+require File.join specs_path, 'support', 'factories', 'commit'
+require File.join specs_path, 'support', 'factories', 'commands'
+require File.join specs_path, 'support', 'filters'
+require File.join specs_path, 'support', 'stub_retrying_subscription'
+require File.join specs_path, 'support', 'sample_model', 'commands'
+require File.join specs_path, 'support', 'sample_model', 'counter'
+require File.join specs_path, 'support', 'sample_model', 'counter2'
+
+Safely.configure do |config|
+  config.strategies = [ Safely::Strategy::Log ]
+end
+
+amqp_config = { :host => 'localhost',
+                :virtual_host => 'euston-daemons-test',
+                :username => 'euston-daemons-test-user',
+                :password => 'password' }
+
+mongo_connection     = Mongo::Connection.from_uri 'mongodb://0.0.0.0:27017/?safe=true;fsync=true;autoconnectretry=true;w=1;'
+event_store_database = Mongo::DB.new 'euston-daemons-test-event-store', mongo_connection
+projections_database = Mongo::DB.new 'euston-daemons-test-projections', mongo_connection
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  config.before(:each) do
+    @event_store_database = event_store_database
+    @projections_database = projections_database
+  end
+
+  config.before(:each, :euston_event_store) do
+    mongo_config = Euston::EventStore::Persistence::Mongodb::Config.instance
+    mongo_config.database = event_store_database.name
+
+    @persistence_factory = Euston::EventStore::Persistence::Mongodb::MongoPersistenceFactory.build
+    @persistence_factory.init
+
+    @event_store = Euston::EventStore::OptimisticEventStore.new @persistence_factory
+    Euston::Repository.event_store = @event_store
+
+    def publish_command command
+      hash = command.to_hash
+      command = { :headers => Euston::CommandHeaders.from_hash(hash[:headers]), :body => hash[:body] }
+      Euston::CommandBus.publish command[:headers], command[:body]
+    end
+  end
+
+  config.before(:each, :purge_event_store) do
+    purge_database event_store_database
+  end
+
+  config.before(:each, :purge_mongo) do
+    purge_database event_store_database
+    purge_database projections_database
+  end
+
+  config.before(:each, :purge_rabbitmq) do
+    initialize_rabbitmq amqp_config
+  end
+
+  config.before(:all, :purge_rabbitmq) do
+    @amqp_connection = HotBunnies.connect amqp_config
+
+    initialize_amqp @amqp_connection
+  end
+
+  config.before(:each, :purge_projections) do
+    purge_database projections_database
+  end
+
+  config.after(:all, :purge_rabbitmq) do
+    @channel.close
+    @amqp_connection.close
+  end
+end

data/spec/support/factories/commands.rb

@@ -0,0 +1,16 @@
+class Cranky::Factory
+  def create_counter_command
+    hash = define :class => Hash,
+                  :id    => Uuid.generate
+
+    Euston::Daemons::SampleModel::CreateCounter.new hash
+  end
+
+  def increment_counter_command
+    hash = define :class       => Hash,
+                  :counter_id  => Uuid.generate,
+                  :amount      => 1 + rand(9)
+
+    Euston::Daemons::SampleModel::IncrementCounter.new hash
+  end
+end

data/spec/support/factories/commit.rb

@@ -0,0 +1,7 @@
+class Cranky::Factory
+  def commit
+    Euston::EventStore::Commit.new :stream_id => Uuid.generate,
+                                   :commit_id => Uuid.generate,
+                                   :events => (1..(rand(2) + 1)).map { Factory.build :event_message }
+  end
+end