euston-daemons 1.0.4-java → 1.1.0-java

data/spec/daemons/command_buffer_publisher_spec.rb

@@ -0,0 +1,110 @@
+describe 'command buffer publisher client', :purge_event_store do
+  require 'euston-daemons/message_buffer_daemon/lib/clients/euston_exchange_accessors'
+  require 'euston-daemons/message_buffer_daemon/lib/clients/mongo_model_accessors'
+  require 'euston-daemons/message_buffer_daemon/lib/clients/message_buffer_publisher'
+  require 'euston-daemons/message_buffer_daemon/lib/clients/command_buffer_publisher'
+  require 'euston-daemons/message_buffer_daemon/lib/mongo_models/message_buffer'
+  require 'euston-daemons/message_buffer_daemon/lib/mongo_models/command_buffer'
+
+  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::MessageBufferDaemon::MongoModel::CommandBuffer.new @event_store_database }
+  let(:publisher)   { Euston::MessageBufferDaemon::CommandBufferPublisher.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 publisher runs' do
+      before { publisher.run }
+
+      describe 'published commands' do
+        subject { published }
+        it      { should be_empty }
+      end
+    end
+  end
+
+  context 'there is a due command' do
+
+    before do
+      buffer.buffer_new_message command
+    end
+
+    describe 'command buffer size' do
+      subject { collection.count }
+      it      { should == 1 }
+    end
+
+    context 'the publisher runs' do
+      before { publisher.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.find_one }
+        its(['next_attempt']) { should > Time.now.to_f + 2 }
+      end
+    end
+  end
+
+  context 'there is a command that is not yet due' do
+    before do
+      buffer.buffer_new_message command
+      collection.update({}, { '$set' => { 'next_attempt' => Time.now.to_f + 1000 } }, { :safe => true })
+    end
+
+    context 'the publisher runs' do
+      before { publisher.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.buffer_new_message command, Time.now.to_f + 1000
+    end
+
+    context 'the publisher runs' do
+      before { publisher.run }
+
+      describe 'published commands' do
+        subject { published }
+        it      { should be_empty }
+      end
+    end
+  end
+end

data/spec/daemons/command_handler_spec.rb

@@ -0,0 +1,48 @@
+describe 'command handler client', :purge_event_store, :purge_rabbitmq do
+  require 'euston-daemons/command_processor_daemon/lib/clients/command_handler'
+
+  let(:logger)            { Euston::NullLogger.instance }
+  let(:handlers)          { [] }
+  let(:subscription)      { StubRetryingSubscription.new }
+  let(:client)            { Euston::CommandProcessorDaemon::CommandHandler.new @channel, handlers, 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_handler_spec.rb

@@ -0,0 +1,55 @@
+describe 'event handler client', :purge_event_store, :purge_rabbitmq do
+  require 'euston-daemons/event_processor_daemon/lib/clients/event_handler'
+
+  let(:logger)            { Euston::NullLogger.instance }
+  let(:subscription)      { StubRetryingSubscription.new }
+  let(:client)            { Euston::EventProcessorDaemon::EventHandler.new @channel, reference, 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/snapshot_client_spec.rb

@@ -0,0 +1,98 @@
+describe 'snapshot client', :purge_event_store, :euston_event_store do
+  require 'euston-daemons/snapshot_daemon/lib/clients/snapshotter'
+
+  let(:logger)      { Euston::NullLogger.instance }
+  let(:threshold)   { 2 }
+  let(:snapshotter) { Euston::SnapshotDaemon::Snapshotter.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(:logger)      { Logger.new(STDOUT) }
+
+    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,77 @@
+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 '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', :vhost => 'euston-daemons-test', :user => 'euston-daemons-test-user', :pass => 'password' }
+
+mongo_connection      = Mongo::Connection.from_uri 'mongodb://0.0.0.0:27017/', :safe => true, :fsync => true, :journal => true
+event_store_database  = Mongo::DB.new 'euston-daemons-test-event-store', mongo_connection
+read_model_database   = Mongo::DB.new 'euston-daemons-test-read-model',  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
+    @read_model_database  = read_model_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 read_model_database
+  end
+
+  config.before(:each, :purge_rabbitmq) do
+    initialize_rabbitmq amqp_config
+    initialize_amqp amqp_config
+  end
+
+  config.before(:each, :purge_read_model) do
+    purge_database read_model_database
+  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

data/spec/support/factories/event_message.rb

@@ -0,0 +1,12 @@
+class Cranky::Factory
+  def event_message
+    headers = { :id         => Euston.uuid.generate,
+                :type       => Faker::Lorem.words(2).join('_'),
+                :version    => 1,
+                :timestamp  => Time.now.to_f }
+
+    body    = { :number => rand(9) + 1 }
+
+    Euston::EventStore::EventMessage.new 'headers' => headers, 'body' => body
+  end
+end

data/spec/support/factories/events.rb

@@ -0,0 +1,8 @@
+# class Cranky::Factory
+#   def empty_event
+#     { :headers => { :id => Uuid.generate, :version => 1 }, :body => { } }
+#     hash = define :class => Hash,
+#                   :id    => Uuid.generate,
+#                   :type  => F
+#   end
+# end

data/spec/support/filters.rb

@@ -0,0 +1,14 @@
+def initialize_amqp config
+  AMQP.settings.merge! config
+  @channel = AMQP::Channel.new
+end
+
+def initialize_rabbitmq config
+  @rabbitmqadmin = RabbitMqAdminCli.new
+  @rabbitmqadmin.initialize_vhost config[:vhost]
+  @rabbitmqadmin.initialize_user  config[:vhost], config[:user], config[:pass]
+end
+
+def purge_database database
+  database.collections.each { |collection| collection.remove unless collection.name.downcase =~ /^system/ }
+end

data/spec/support/sample_model/commands.rb

@@ -0,0 +1,14 @@
+module Euston
+  module Daemons
+    module SampleModel
+      class CreateCounter < Euston::Command
+        validates :id, :presence => true
+      end
+
+      class IncrementCounter < Euston::Command
+        validates :counter_id, :presence => true
+        validates :amount,     :presence => true
+      end
+    end
+  end
+end

data/spec/support/sample_model/counter.rb

@@ -0,0 +1,36 @@
+module Euston
+  module Daemons
+    module SampleModel
+      class Counter
+        include Euston::AggregateRoot
+
+        created_by :create_counter do |command|
+          apply_event :counter_created, 1, command
+        end
+
+        consumes :increment_counter, :id => :counter_id do |command|
+          apply_event :counter_incremented, 1, :count => @count + command.amount
+        end
+
+        applies :counter_created do |event|
+          @count = 0
+        end
+
+        applies :counter_incremented do |event|
+          @count = event.count
+        end
+
+        load_snapshot 1 do |snapshot|
+          @count = snapshot[:count]
+          @snapshot_loaded = snapshot
+        end
+
+        take_snapshot 1 do
+          { :count => @count }
+        end
+
+        attr_reader :count, :snapshot_loaded
+      end
+    end
+  end
+end

data/spec/support/sample_model/counter2.rb

@@ -0,0 +1,46 @@
+module Euston
+  module Daemons
+    module SampleModel
+      class Counter2
+        include Euston::AggregateRoot
+
+        created_by :create_counter do |command|
+          apply_event :counter_created, 1, command
+        end
+
+        consumes :increment_counter, :id => :counter_id do |command|
+          apply_event :counter_incremented, 1, :count => @count + command.amount
+        end
+
+        subscribes :external_thing_happened do |headers, event|
+          apply_event :noted_that_external_thing_happened, 1
+        end
+
+        applies :counter_created do |event|
+          @count = 0
+          @external_thing_happened = false
+        end
+
+        applies :counter_incremented do |event|
+          @count = event.count
+        end
+
+        applies :noted_that_external_thing_happened do |event|
+          @external_thing_happened = true
+        end
+
+        load_snapshot 1 do |snapshot|
+          @count = snapshot[:count]
+          @external_thing_happened = snapshot[:heard_about_external_thing]
+          @snapshot_loaded = snapshot
+        end
+
+        take_snapshot 1 do
+          { :count => @count, :heard_about_external_thing => @external_thing_happened }
+        end
+
+        attr_reader :count, :snapshot_loaded
+      end
+    end
+  end
+end

data/spec/support/stub_retrying_subscription.rb

@@ -0,0 +1,9 @@
+class StubRetryingSubscription
+  include Hollywood
+
+  def subscribe; end
+
+  def stub_message_receipt message
+    callback :message_received, message
+  end
+end