synapse-core 0.2.0 → 0.4.0

data/lib/synapse/serialization.rb

@@ -23,9 +23,9 @@ module Synapse
   end
 end
 
+require 'synapse/serialization/converter_factory'
 require 'synapse/serialization/converter'
 require 'synapse/serialization/converter/chain'
-require 'synapse/serialization/converter/factory'
 require 'synapse/serialization/converter/identity'
 
 require 'synapse/serialization/errors'

data/lib/synapse/serialization/serializer.rb

@@ -4,13 +4,15 @@ module Synapse
     # @abstract
     class Serializer
       # @return [ConverterFactory]
-      attr_accessor :converter_factory
+      attr_reader :converter_factory
 
       # @return [RevisionResolver]
       attr_accessor :revision_resolver
 
-      def initialize
-        @converter_factory = ConverterFactory.new
+      # @param [ConverterFactory] converter_factory
+      # @return [undefined]
+      def initialize(converter_factory)
+        @converter_factory = converter_factory
       end
 
       # @param [Object] object

data/lib/synapse/uow/listener_collection.rb

@@ -14,6 +14,7 @@ module Synapse
     class UnitOfWorkListenerCollection < UnitOfWorkListener
       def initialize
         @listeners = Array.new
+        @logger = Logging.logger[self.class]
       end
 
       # Pushes a unit of work listener onto the end of this collection
@@ -21,6 +22,10 @@ module Synapse
       # @param [UnitOfWorkListener] listener
       # @return [undefined]
       def push(listener)
+        if @logger.debug?
+          @logger.debug 'Registering listener [%s]' % listener.class
+        end
+
         @listeners.push listener
       end
 
@@ -29,9 +34,17 @@ module Synapse
       # @param [UnitOfWork] unit
       # @return [undefined]
       def on_start(unit)
+        @logger.debug 'Notifying listeners that unit of work is starting'
+
         @listeners.each do |listener|
+          if @logger.debug?
+            @logger.debug 'Notifying [%s] of start' % listener.class
+          end
+
           listener.on_start unit
         end
+
+        @logger.debug 'Listeners successfully notified'
       end
 
       # @param [UnitOfWork] unit
@@ -50,43 +63,88 @@ module Synapse
       # @param [Hash<EventBus, Array>] events
       # @return [undefined]
       def on_prepare_commit(unit, aggregates, events)
+        @logger.debug 'Notifying listeners that commit was requested'
+
         @listeners.each do |listener|
+          if @logger.debug?
+            @logger.debug 'Notifying [%s] of commit' % listener.class
+          end
+
           listener.on_prepare_commit unit, aggregates, events
         end
+
+        @logger.debug 'Listeners successfully notified'
       end
 
       # @param [UnitOfWork] unit
       # @param [Object] transaction
       # @return [undefined]
       def on_prepare_transaction_commit(unit, transaction)
+        @logger.debug 'Notifying listeners that transactional commit was requested'
+
         @listeners.each do |listener|
+          if @logger.debug?
+            @logger.debug 'Notifying [%s] of transactional commit' % listener.class
+          end
+
           listener.on_prepare_transaction_commit unit, transaction
         end
+
+        @logger.debug 'Listeners successfully notified'
       end
 
       # @param [UnitOfWork] unit
       # @return [undefined]
       def after_commit(unit)
+        @logger.debug 'Notifying listeners that commit has finished'
+
         @listeners.reverse_each do |listener|
+          if @logger.debug?
+            @logger.debug 'Notifying [%s] of finished commit' % listener.class
+          end
+
           listener.after_commit unit
         end
+
+        @logger.debug 'Listeners successfully notified'
       end
 
       # @param [UnitOfWork] unit
       # @param [Error] cause
       # @return [undefined]
       def on_rollback(unit, cause = nil)
+        @logger.debug 'Notifying listeners of rollback'
+
         @listeners.reverse_each do |listener|
+          if @logger.debug?
+            @logger.debug 'Notifying [%s] of rollback' % listener.class
+          end
+
           listener.on_rollback unit, cause
         end
+
+        @logger.debug 'Listeners successfully notified'
       end
 
       # @param [UnitOfWork] unit
       # @return [undefined]
       def on_cleanup(unit)
+        @logger.debug 'Notifying listeners of cleanup'
+
         @listeners.reverse_each do |listener|
-          listener.on_cleanup unit
+          if @logger.debug?
+            @logger.debug 'Notifying [%s] of cleanup' % listener.class
+          end
+
+          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
+          end
         end
+
+        @logger.debug 'Listeners successfully notified'
       end
     end
   end

data/lib/synapse/version.rb

@@ -1,3 +1,3 @@
 module Synapse
-  VERSION = '0.2.0'
+  VERSION = '0.4.0'
 end

data/lib/synapse/wiring/message_wiring.rb

@@ -8,21 +8,25 @@ module Synapse
       included do
         # @return [WireRegistry]
         class_attribute :wire_registry
+
+        # By default, the wire registry allows duplicates
+        self.wire_registry = Wiring::WireRegistry.new true
       end
 
       module ClassMethods
         def wire(type, *args, &block)
           options = args.extract_options!
 
-          unless options[:to]
+          to = options.delete :to
+          unless to
             unless block
               raise ArgumentError, 'Expected block or option :to'
             end
 
-            options[:to] = block
+            to = block
           end
 
-          wire = Wire.new type, options[:to]
+          wire = Wire.new type, options, to
 
           self.wire_registry.register wire
         end

data/lib/synapse/wiring/wire.rb

@@ -11,11 +11,16 @@ module Synapse
       # @return [Object] Either a method symbol or block
       attr_reader :handler
 
+      # @return [Hash] Options specific to the component being wired
+      attr_reader :options
+
       # @param [Class] type
+      # @param [Hash] options
       # @param [Object] handler Either a method symbol or block
-      # @return [undefined]]
-      def initialize(type, handler)
+      # @return [undefined]
+      def initialize(type, options, handler)
         @type = type
+        @options = options
         @handler = handler
       end
 

data/test/common/concurrency/identifier_lock_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+module Synapse
+  class IdentifierLockTest < Test::Unit::TestCase
+    def test_disposal
+      lock = IdentifierLock.new
+      identifier = 'some_id'
+
+      lock.obtain_lock identifier
+      lock.release_lock identifier
+
+      identifiers = lock.instance_variable_get :@identifiers
+      refute identifiers.has_key? identifier
+    end
+
+    def test_owned?
+      lock = IdentifierLock.new
+      identifier = 'some_id'
+
+      refute lock.owned? identifier
+
+      lock.obtain_lock identifier
+      assert lock.owned? identifier
+
+      lock.release_lock identifier
+      refute lock.owned? identifier
+    end
+
+    def test_release_lock
+      lock = IdentifierLock.new
+      assert_raise ThreadError do
+        lock.release_lock 'derp'
+      end
+    end
+  end
+end

data/test/common/concurrency/public_lock_test.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+
+module Synapse
+  class PublicLockTest < Test::Unit::TestCase
+    def test_lock_raises
+      @lock = PublicLock.new
+      @lock.lock
+
+      assert_raise ThreadError do
+        @lock.lock
+      end
+    end
+
+    def test_lock_removes_waiting
+      @lock = PublicLock.new
+      @lock.lock
+
+      t = Thread.new do
+        @lock.lock
+      end
+
+      wait_until do
+        @lock.waiting == [t]
+      end
+
+      t.kill
+
+      wait_until do
+        @lock.waiting == []
+      end
+    end
+
+    def test_synchronize
+      @lock = PublicLock.new
+
+      refute @lock.owned?
+      refute @lock.owned_by? Thread.current
+
+      @lock.synchronize do
+        assert @lock.owned?
+        assert @lock.owned_by? Thread.current
+      end
+
+      refute @lock.owned?
+      refute @lock.owned_by? Thread.current
+    end
+
+    def test_unlock_raises
+      @lock = PublicLock.new
+
+      assert_raise ThreadError do
+        @lock.unlock
+      end
+    end
+
+    def test_try_lock
+      @lock = PublicLock.new
+
+      t = Thread.new do
+        assert @lock.try_lock
+        Thread.stop
+        @lock.unlock
+      end
+
+      wait_until do
+        @lock.owned_by? t
+      end
+
+      refute @lock.try_lock
+
+      t.wakeup
+    end
+
+    def test_try_lock_raises
+      @lock = PublicLock.new
+      @lock.try_lock
+
+      assert_raise ThreadError do
+        @lock.try_lock
+      end
+    end
+  end
+end

data/test/partitioning/packing/json_test.rb

@@ -5,7 +5,8 @@ module Synapse
 
     class JsonPackingTest < Test::Unit::TestCase
       def setup
-        @serializer = Serialization::MarshalSerializer.new
+        @converter_factory = Serialization::ConverterFactory.new
+        @serializer = Serialization::MarshalSerializer.new @converter_factory
         @packer = JsonMessagePacker.new @serializer
         @unpacker = JsonMessageUnpacker.new @serializer
       end

data/test/process_manager/in_memory_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+module Synapse
+  module ProcessManager
+
+    class InMemoryProcessRepositoryTest < Test::Unit::TestCase
+      def test_find
+        correlation_a = Correlation.new :order_id, 1
+        correlation_b = Correlation.new :order_id, 2
+
+        process_a = Process.new
+        process_a.correlations.add correlation_a
+        process_b = Process.new
+        process_b.correlations.add correlation_b
+
+        repository = InMemoryProcessRepository.new
+        repository.add process_a
+        repository.add process_b
+
+        assert_equal [process_a.id], repository.find(Process, correlation_a)
+        assert_equal [process_b.id], repository.find(Process, correlation_b)
+      end
+
+      def test_load
+        repository = InMemoryProcessRepository.new
+
+        process_a = Process.new
+        process_b = Process.new
+
+        repository.add process_a
+        repository.add process_b
+
+        assert_equal process_a, repository.load(process_a.id)
+        assert_equal process_b, repository.load(process_b.id)
+      end
+
+      def test_commit
+        repository = InMemoryProcessRepository.new
+
+        process = Process.new
+        repository.commit process
+
+        assert_equal 1, repository.count
+        # Make sure the correlation set was marked as committed
+        assert_equal 0, process.correlations.additions.count
+        assert_equal 0, process.correlations.deletions.count
+
+        process.send :finish
+
+        repository.commit process
+
+        assert_equal 0, repository.count
+      end
+    end
+
+  end
+end

data/test/process_manager/process_factory_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Synapse
+  module ProcessManager
+    class GenericProcessFactoryTest < Test::Unit::TestCase
+      def test_create
+        injector = Object.new
+
+        mock(injector).inject_resources(is_a(Process))
+
+        factory = GenericProcessFactory.new
+        factory.resource_injector = injector
+
+        process = factory.create Process
+
+        assert process.is_a? Process
+      end
+
+      def test_supports
+        factory = GenericProcessFactory.new
+
+        assert factory.supports Process
+        refute factory.supports StubProcessWithArguments
+      end
+    end
+
+    class StubProcessWithArguments < Process
+      def initialize(some_resource); end
+    end
+  end
+end

data/test/process_manager/simple_process_manager_test.rb

@@ -0,0 +1,130 @@
+require 'test_helper'
+
+module Synapse
+  module ProcessManager
+    class SimpleProcessManagerTest < Test::Unit::TestCase
+      def setup
+        @repository = InMemoryProcessRepository.new
+        @factory = GenericProcessFactory.new
+        @resolver = MetadataCorrelationResolver.new :order_id
+        @lock_manager = Object.new
+        @manager = SimpleProcessManager.new @repository, @factory, @lock_manager, @resolver, TestProcess
+      end
+
+      def test_notify_new_process
+        @manager.optionally_create_events << CauseProcessCreationEvent
+
+        correlation = Correlation.new :order_id, 123
+
+        mock(@lock_manager).obtain_lock(is_a(String))
+        mock(@lock_manager).release_lock(is_a(String))
+
+        @manager.notify create_event 123, CauseProcessCreationEvent.new
+
+        assert_equal 1, @repository.count
+      end
+
+      def test_notify_existing_process
+        process = TestProcess.new
+        process.correlations.add Correlation.new :order_id, 123
+
+        @repository.add process
+
+        mock(@lock_manager).obtain_lock(process.id)
+        mock(@lock_manager).release_lock(process.id)
+
+        @manager.notify create_event 123, CauseProcessNotificationEvent.new
+
+        assert_equal 1, @repository.count
+      end
+
+      def test_notify_process_raises_but_suppressed
+        process = TestProcess.new
+        process.correlations.add Correlation.new :order_id, 123
+
+        @repository.add process
+
+        mock(@lock_manager).obtain_lock(process.id)
+        mock(@lock_manager).release_lock(process.id)
+
+        @manager.notify create_event 123, CauseProcessRaiseExceptionEvent.new
+
+        assert_equal 1, @repository.count
+      end
+
+      def test_notify_process_raises
+        process = TestProcess.new
+        process.correlations.add Correlation.new :order_id, 123
+
+        @repository.add process
+
+        mock(@lock_manager).obtain_lock(process.id)
+        mock(@lock_manager).release_lock(process.id)
+
+        @manager.suppress_exceptions = false
+
+        assert_raise RuntimeError do
+          @manager.notify create_event 123, CauseProcessRaiseExceptionEvent.new
+        end
+      end
+
+      def test_always_create
+        @manager.always_create_events << CauseProcessCreationEvent
+
+        correlation = Correlation.new :order_id, 123
+
+        # Lock is obtain/released for the 2 being created and once for the first being changed
+        mock(@lock_manager).obtain_lock(is_a(String)).times(3)
+        mock(@lock_manager).release_lock(is_a(String)).times(3)
+
+        @manager.notify create_event 123, CauseProcessCreationEvent.new
+        @manager.notify create_event 123, CauseProcessCreationEvent.new
+
+        assert_equal 2, @repository.count
+      end
+
+    private
+
+      def create_event(order_id, event)
+        Domain::EventMessage.build do |builder|
+          builder.payload = event
+          builder.metadata = {
+            order_id: order_id
+          }
+        end
+      end
+    end
+
+    # Example correlation resolver
+    class MetadataCorrelationResolver < CorrelationResolver
+      def initialize(property)
+        @property = property
+      end
+
+      def resolve(event)
+        value = event.metadata[@property]
+        if value
+          Correlation.new @property, value
+        end
+      end
+    end
+
+    # Test process that has all sorts of trigger events
+    class TestProcess < Process
+      attr_accessor :handled
+
+      def handle(event)
+        if event.payload_type == CauseProcessRaiseExceptionEvent
+          raise 'ohgodimnotgoodwithcomputers'
+        end
+
+        @handled ||= 0
+        @handled = @handled.next
+      end
+    end
+
+    class CauseProcessCreationEvent; end
+    class CauseProcessNotificationEvent; end
+    class CauseProcessRaiseExceptionEvent; end
+  end
+end