synapse-core 0.5.6 → 0.6.0

data/lib/synapse/uow/listener_collection.rb

@@ -12,6 +12,7 @@ module Synapse
     # before any listeners are allowed to do anything, and log that the commit is finished after
     # all other listeners have finished.
     class UnitOfWorkListenerCollection < UnitOfWorkListener
+      # @return [undefined]
       def initialize
         @listeners = Array.new
         @logger = Logging.logger[self.class]
@@ -22,17 +23,17 @@ module Synapse
       # @param [UnitOfWorkListener] listener
       # @return [undefined]
       def push(listener)
-        @logger.debug 'Registering listener [%s]' % listener.class
+        @logger.debug "Registering listener {#{listener.class}}"
         @listeners.push listener
       end
 
-      alias << push
+      alias_method :<<, :push
 
       # @param [UnitOfWork] unit
       # @return [undefined]
       def on_start(unit)
         @listeners.each do |listener|
-          @logger.debug 'Notifying [%s] of start' % listener.class
+          @logger.debug "Notifying {#{listener.class}} that unit of work is starting"
           listener.on_start unit
         end
       end
@@ -54,7 +55,7 @@ module Synapse
       # @return [undefined]
       def on_prepare_commit(unit, aggregates, events)
         @listeners.each do |listener|
-          @logger.debug 'Notifying [%s] of commit' % listener.class
+          @logger.debug "Notifying {#{listener.class}} that unit of work is preparing for commit"
           listener.on_prepare_commit unit, aggregates, events
         end
       end
@@ -64,7 +65,7 @@ module Synapse
       # @return [undefined]
       def on_prepare_transaction_commit(unit, transaction)
         @listeners.each do |listener|
-          @logger.debug 'Notifying [%s] of transactional commit' % listener.class
+          @logger.debug "Notifying {#{listener.class}} that unit of work is preparing for tx commit"
           listener.on_prepare_transaction_commit unit, transaction
         end
       end
@@ -73,7 +74,7 @@ module Synapse
       # @return [undefined]
       def after_commit(unit)
         @listeners.reverse_each do |listener|
-          @logger.debug 'Notifying [%s] of finished commit' % listener.class
+          @logger.debug "Notifying {#{listener.class}} that unit of work has been committed"
           listener.after_commit unit
         end
       end
@@ -83,7 +84,7 @@ module Synapse
       # @return [undefined]
       def on_rollback(unit, cause = nil)
         @listeners.reverse_each do |listener|
-          @logger.debug 'Notifying [%s] of rollback' % listener.class
+          @logger.debug "Notifying {#{listener.class}} that unit of work is rolling back"
           listener.on_rollback unit, cause
         end
       end
@@ -92,13 +93,15 @@ module Synapse
       # @return [undefined]
       def on_cleanup(unit)
         @listeners.reverse_each do |listener|
-          @logger.debug 'Notifying [%s] of cleanup' % listener.class
+          @logger.debug "Notifying {#{listener.class}} that unit of work is cleaning up"
 
           begin
             listener.on_cleanup unit
           rescue => exception
             # Ignore this exception so that we can continue cleaning up
-            @logger.warn 'Listener raised an exception during cleanup: %s' % exception.inspect
+            backtrace = exception.backtrace.join $RS
+            @logger.warn "Listener {#{listener.class}} raised exception during cleanup: " +
+              "#{exception.inspect} #{backtrace}"
           end
         end
       end

data/lib/synapse/uow/provider.rb

@@ -3,6 +3,7 @@ module Synapse
     # Entry point for components to access units of work. Components managing transactional
     # boundaries can register and clear unit of work instances.
     class UnitOfWorkProvider
+      # @return [undefined]
       def initialize
         @threads = Hash.new
       end
@@ -40,7 +41,6 @@ module Synapse
         stack.last
       end
 
-
       # Pushes the given unit of work onto the top of the stack, making it the active unit of work
       #
       # If there are other units of work bound to this provider, they will be held until the given

data/lib/synapse/uow/uow.rb

@@ -160,7 +160,7 @@ module Synapse
       # @return [AggregateRoot] Returns nil if no similar aggregate was found
       def find_similar_aggregate(aggregate)
         @aggregates.each_key do |candidate|
-          if aggregate.class === candidate and aggregate.id == candidate.id
+          if aggregate.class === candidate && aggregate.id == candidate.id
             return candidate
           end
         end

data/lib/synapse/upcasting/upcaster_chain.rb

@@ -22,7 +22,7 @@ module Synapse
         @upcasters.push upcaster
       end
 
-      alias << push
+      alias_method :<<, :push
 
       # @param [SerializedObject] serialized_object
       # @param [UpcastingContext] upcast_context

data/lib/synapse/version.rb

@@ -1,3 +1,3 @@
 module Synapse
-  VERSION = '0.5.6'
+  VERSION = '0.6.0'
 end

data/test/command/serialization_test.rb

@@ -10,11 +10,14 @@ module Synapse
         command = CommandMessage.build
         chain = Object.new
         unit = Object.new
+        result = Object.new
 
-        mock(chain).proceed(command)
+        mock(chain).proceed(command) do
+          result
+        end
         mock(unit).register_listener(is_a(SerializationOptimizingListener))
 
-        interceptor.intercept(command, unit, chain)
+        assert_same result, interceptor.intercept(command, unit, chain)
       end
     end
 

data/test/command/simple_command_bus_test.rb

@@ -108,29 +108,22 @@ module Synapse
         @command_bus.dispatch_with_callback command, callback
       end
 
-      should 'log when a subscribed handler is replaced' do
-        handler = Object.new
-
-        mock(@logger).debug(anything).ordered
-        mock(@logger).info(anything).ordered
+      should 'return the previous handler when a subscribed handler is replaced' do
+        handler_a = Object.new
+        handler_b = Object.new
 
-        @command_bus.subscribe TestCommand, handler
-        @command_bus.subscribe TestCommand, handler
+        assert_nil (@command_bus.subscribe TestCommand, handler_a)
+        assert_same (@command_bus.subscribe TestCommand, handler_b), handler_a
       end
 
-      should 'log when a handler is unsubscribed' do
+      should 'return true when a handler is unsubscribed' do
         handler_a = Object.new
         handler_b = Object.new
 
-        mock(@logger).info(anything).ordered # not subscribed to anyone
-        mock(@logger).debug(anything).ordered # now subscribed
-        mock(@logger).info(anything).ordered # subscribed to different
-        mock(@logger).debug(anything).ordered # now unsubscribed
-
-        @command_bus.unsubscribe TestCommand, handler_a
+        refute @command_bus.unsubscribe TestCommand, handler_a
         @command_bus.subscribe TestCommand, handler_a
-        @command_bus.unsubscribe TestCommand, handler_b
-        @command_bus.unsubscribe TestCommand, handler_a
+        refute @command_bus.unsubscribe TestCommand, handler_b
+        assert @command_bus.unsubscribe TestCommand, handler_a
       end
     end
 

data/test/command/validation_test.rb

@@ -11,7 +11,7 @@ module Synapse
         end
 
         filter = ActiveModelValidationFilter.new
-        filter.filter message
+        assert_same message, filter.filter(message)
       end
 
       should 'raise an exception if payload of a command message is invalid' do

data/test/common/concurrency/identifier_lock_manager_test.rb

@@ -0,0 +1,137 @@
+require 'test_helper'
+
+module Synapse
+  class IdentifierLockManagerTest < Test::Unit::TestCase
+    CountdownLatch = Contender::CountdownLatch
+
+    should 'dispose locks when they are no longer in use' do
+      manager = IdentifierLockManager.new
+
+      identifier = SecureRandom.uuid
+      manager.obtain_lock identifier
+      manager.release_lock identifier
+
+      assert_equal 0, manager.internal_locks.size
+    end
+
+    should 'not dispose locks when they are still in use' do
+      manager = IdentifierLockManager.new
+
+      identifier = SecureRandom.uuid
+
+      refute manager.owned? identifier
+
+      manager.obtain_lock identifier
+      assert manager.owned? identifier
+
+      manager.obtain_lock identifier
+      assert manager.owned? identifier
+
+      manager.release_lock identifier
+      assert manager.owned? identifier
+
+      manager.release_lock identifier
+      refute manager.owned? identifier
+    end
+
+    should 'detect a deadlock between two threads' do
+      manager = IdentifierLockManager.new
+
+      start_latch = CountdownLatch.new 1
+      latch = CountdownLatch.new 1
+      deadlock = Atomic.new false
+
+      lock_a = SecureRandom.uuid
+      lock_b = SecureRandom.uuid
+
+      start_lock_thread start_latch, latch, deadlock, manager, lock_a, manager, lock_b
+
+      manager.obtain_lock lock_b
+
+      start_latch.await
+      latch.countdown
+
+      begin
+        manager.obtain_lock lock_a
+        assert deadlock.get
+      rescue DeadlockError
+        # This is expected behavior
+      end
+    end
+
+    should 'detect a deadlock between two threads across lock managers' do
+      manager_a = IdentifierLockManager.new
+      manager_b = IdentifierLockManager.new
+
+      start_latch = CountdownLatch.new 1
+      latch = CountdownLatch.new 1
+      deadlock = Atomic.new false
+
+      lock_a = SecureRandom.uuid
+      lock_b = SecureRandom.uuid
+
+      start_lock_thread start_latch, latch, deadlock, manager_a, lock_a, manager_b, lock_a
+
+      manager_b.obtain_lock lock_a
+
+      start_latch.await
+      latch.countdown
+
+      begin
+        manager_a.obtain_lock lock_a
+        assert deadlock.get
+      rescue DeadlockError
+        # This is expected behavior
+      end
+    end
+
+    should 'detect a deadlock between three threads in a vector' do
+      manager = IdentifierLockManager.new
+
+      start_latch = CountdownLatch.new 3
+      latch = CountdownLatch.new 1
+      deadlock = Atomic.new false
+
+      lock_a = SecureRandom.uuid
+      lock_b = SecureRandom.uuid
+      lock_c = SecureRandom.uuid
+      lock_d = SecureRandom.uuid
+
+      start_lock_thread start_latch, latch, deadlock, manager, lock_a, manager, lock_b
+      start_lock_thread start_latch, latch, deadlock, manager, lock_b, manager, lock_c
+      start_lock_thread start_latch, latch, deadlock, manager, lock_c, manager, lock_d
+
+      manager.obtain_lock lock_d
+
+      start_latch.await
+      latch.countdown
+
+      begin
+        manager.obtain_lock lock_a
+        assert deadlock.get
+      rescue DeadlockError
+        # This is expected behavior
+      end
+    end
+
+  private
+
+    def start_lock_thread(start_latch, latch, deadlock, manager_a, lock_a, manager_b, lock_b)
+      Thread.new do
+        manager_a.obtain_lock lock_a
+        start_latch.countdown
+
+        begin
+          latch.await
+
+          manager_b.obtain_lock lock_b
+          manager_b.release_lock lock_b
+        rescue DeadlockError
+          deadlock.set true
+        ensure
+          manager_a.release_lock lock_a
+        end
+      end
+    end
+  end
+end

data/test/configuration/component/serialization/converter_factory_test.rb

@@ -33,7 +33,7 @@ module Synapse
         @builder.converter_factory
 
         factory = @container.resolve :converter_factory
-        factory.converters.at(0).is_a? Serialization::JsonToObjectConverter
+        factory.converters.first.is_a? Serialization::JsonToObjectConverter
 
         # Customized
         @builder.converter_factory :alt_factory do
@@ -41,7 +41,7 @@ module Synapse
         end
 
         factory = @container.resolve :alt_factory
-        factory.converters.at(0).is_a? Serialization::JsonToObjectConverter
+        factory.converters.first.is_a? Serialization::JsonToObjectConverter
       end
     end
   end

data/test/event_sourcing/repository_test.rb

@@ -70,6 +70,24 @@ module Synapse
         end
       end
 
+      should 'raise an exception while saving if lock could not be validated' do
+        event = create_event(123, 0, StubCreatedEvent.new(123))
+
+        mock(@event_store).read_events(@factory.type_identifier, 123) do
+          Domain::SimpleDomainEventStream.new event
+        end
+
+        aggregate = @repository.load 123
+
+        mock(@lock_manager).validate_lock(aggregate) do
+          false
+        end
+
+        assert_raise Repository::ConcurrencyError do
+          @unit.commit
+        end
+      end
+
       should 'defer version checking to a conflict resolver if one is set' do
         @repository.conflict_resolver = AcceptAllConflictResolver.new
 

data/test/repository/simple_repository_test.rb

@@ -2,12 +2,15 @@ require 'test_helper'
 
 module Synapse
   module Repository
+
     class SimpleRepositoryTest < Test::Unit::TestCase
       def setup
         @unit_provider = UnitOfWork::UnitOfWorkProvider.new
         @unit_factory = UnitOfWork::UnitOfWorkFactory.new @unit_provider
 
-        @repository = SimpleRepository.new NullLockManager.new, TestMappedAggregate
+        @lock_manager = NullLockManager.new
+
+        @repository = SimpleRepository.new @lock_manager, TestMappedAggregate
         @repository.event_bus = EventBus::SimpleEventBus.new
         @repository.unit_provider = @unit_provider
       end
@@ -15,43 +18,71 @@ module Synapse
       should 'load an aggregate using its finder' do
         unit = @unit_factory.create
 
-        aggregate = TestMappedAggregate.new '5677b4f7'
-        mock(TestMappedAggregate).find(aggregate.id) do
+        aggregate_id = SecureRandom.uuid
+        aggregate = TestMappedAggregate.new aggregate_id
+
+        mock(TestMappedAggregate).find(aggregate_id) do
           aggregate
         end
 
-        loaded = @repository.load aggregate.id
+        loaded = @repository.load aggregate_id
 
         assert_same loaded, aggregate
       end
 
       should 'raise an exception if the aggregate could not be found' do
-        mock(TestMappedAggregate).find('5677b4f7')
+        aggregate_id = SecureRandom.uuid
+
+        mock(TestMappedAggregate).find(aggregate_id)
 
         assert_raise AggregateNotFoundError do
-          @repository.load '5677b4f7'
+          @repository.load aggregate_id
         end
       end
 
       should 'raise an exception if the loaded aggregate has an unexpected version' do
         unit = @unit_factory.create
 
-        aggregate = TestMappedAggregate.new '5677b4f7'
+        aggregate_id = SecureRandom.uuid
+        aggregate = TestMappedAggregate.new aggregate_id
         aggregate.version = 5
 
-        mock(TestMappedAggregate).find(aggregate.id) do
+        mock(TestMappedAggregate).find(aggregate_id) do
           aggregate
         end
 
         assert_raise ConflictingAggregateVersionError do
-          @repository.load aggregate.id, 4
+          @repository.load aggregate_id, 4
+        end
+      end
+
+      should 'raise an exception while saving if lock could not be validated' do
+        unit = @unit_factory.create
+
+        aggregate_id = SecureRandom.uuid
+        aggregate = TestMappedAggregate.new aggregate_id
+        aggregate.version = 5
+
+        mock(TestMappedAggregate).find(aggregate_id) do
+          aggregate
+        end
+
+        @repository.load aggregate_id
+
+        mock(@lock_manager).validate_lock(aggregate) do
+          false
+        end
+
+        assert_raise ConcurrencyError do
+          unit.commit
         end
       end
 
       should 'delete the aggregate if it has been marked for deletion' do
         unit = @unit_factory.create
 
-        aggregate = TestMappedAggregate.new '5677b4f7'
+        aggregate_id = SecureRandom.uuid
+        aggregate = TestMappedAggregate.new aggregate_id
         aggregate.delete_this_thing
 
         @repository.add aggregate
@@ -75,5 +106,6 @@ module Synapse
         mark_deleted
       end
     end
+
   end
 end