synapse-core 0.1.2 → 0.2.0

data/lib/synapse.rb

@@ -1,351 +1,39 @@
 require 'active_support'
 require 'active_support/core_ext'
-require 'eventmachine'
 require 'logging'
 require 'set'
 
 require 'synapse/version'
 
+require 'synapse/common/errors'
+require 'synapse/common/identifier'
+require 'synapse/common/message'
+require 'synapse/common/message_builder'
+
 module Synapse
   extend ActiveSupport::Autoload
 
-  eager_autoload do
-    autoload_at 'synapse/errors' do
-      autoload :SynapseError
-      autoload :ConfigurationError
-      autoload :NonTransientError
-      autoload :TransientError
-    end
-
-    autoload_at 'synapse/identifier' do
-      autoload :IdentifierFactory
-      autoload :GuidIdentifierFactory
-    end
-
-    autoload :Message
-    autoload :MessageBuilder
-
-    autoload_at 'synapse/duplication' do
-      autoload :DuplicationError
-      autoload :DuplicationRecorder
-    end
-  end
-
-  module Command
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload :CommandBus
-      autoload :SimpleCommandBus
-
-      autoload :CommandCallback
-      autoload :CommandFilter
-      autoload :CommandHandler
-
-      autoload_at 'synapse/command/message' do
-        autoload :CommandMessage
-        autoload :CommandMessageBuilder
-      end
-
-      autoload :CommandGateway, 'synapse/command/gateway'
-
-      autoload :DispatchInterceptor
-      autoload :InterceptorChain
-
-      autoload_at 'synapse/command/duplication' do
-        autoload :DuplicationFilter
-        autoload :DuplicationCleanupInterceptor
-      end
-
-      autoload_at 'synapse/command/errors' do
-        autoload :CommandExecutionError
-        autoload :CommandValidationError
-        autoload :NoHandlerError
-      end
-
-      autoload_at 'synapse/command/filters/validation' do
-        autoload :ActiveModelValidationFilter
-        autoload :ActiveModelValidationError
-      end
-
-      autoload_at 'synapse/command/interceptors/serialization' do
-        autoload :SerializationOptimizingInterceptor
-        autoload :SerializationOptimizingListener
-      end
-
-      autoload_at 'synapse/command/rollback_policy' do
-        autoload :RollbackPolicy
-        autoload :RollbackOnAnyExceptionPolicy
-      end
-
-      autoload :WiringCommandHandler, 'synapse/command/wiring'
-    end
+  autoload_at 'synapse/common/duplication' do
+    autoload :DuplicationError
+    autoload :DuplicationRecorder
   end
 
-  module Domain
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload_at 'synapse/domain/aggregate_root' do
-        autoload :AggregateRoot
-        autoload :AggregateIdentifierNotInitializedError
-      end
-
-      autoload :EventContainer
-
-      autoload_at 'synapse/domain/message' do
-        autoload :EventMessage
-        autoload :DomainEventMessage
-      end
-
-      autoload_at 'synapse/domain/message_builder' do
-        autoload :EventMessageBuilder
-        autoload :DomainEventMessageBuilder
-      end
-
-      autoload_at 'synapse/domain/stream' do
-        autoload :DomainEventStream
-        autoload :EndOfStreamError
-        autoload :SimpleDomainEventStream
-      end
-    end
-  end
-
-  module EventBus
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload_at 'synapse/event_bus/event_bus' do
-        autoload :EventBus
-        autoload :SubscriptionFailedError
-      end
-
-      autoload :EventListener
-      autoload :EventListenerProxy
-      autoload :SimpleEventBus
-      autoload :WiringEventListener, 'synapse/event_bus/wiring'
-    end
-  end
-
-  module EventSourcing
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload_at 'synapse/event_sourcing/aggregate_factory' do
-        autoload :AggregateFactory
-        autoload :GenericAggregateFactory
-      end
-
-      autoload :AggregateRoot
-      autoload :Entity
-      autoload :Member
-
-      autoload :EventSourcingRepository, 'synapse/event_sourcing/repository'
-      autoload :EventSourcedStorageListener, 'synapse/event_sourcing/storage_listener'
-      autoload :EventStreamDecorator, 'synapse/event_sourcing/stream_decorator'
-
-      autoload_at 'synapse/event_sourcing/conflict_resolver' do
-        autoload :ConflictResolver
-        autoload :ConflictResolvingUnitOfWorkListener
-        autoload :CapturingEventStream
-      end
-
-      autoload_at 'synapse/event_sourcing/snapshot/taker' do
-        autoload :AggregateSnapshotTaker
-        autoload :DeferredSnapshotTaker
-        autoload :SnapshotTaker
-      end
-
-      autoload_at 'synapse/event_sourcing/snapshot/count_stream' do
-        autoload :CountingEventStream
-        autoload :TriggeringEventStream
-        autoload :SnapshotUnitOfWorkListener
-      end
-
-      autoload :EventCountSnapshotTrigger, 'synapse/event_sourcing/snapshot/count_trigger'
-    end
-  end
-
-  module EventStore
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload_at 'synapse/event_store/errors' do
-        autoload :EventStoreError
-        autoload :StreamNotFoundError
-      end
-
-      autoload_at 'synapse/event_store/event_store' do
-        autoload :EventStore
-        autoload :SnapshotEventStore
-      end
-    end
-
-    autoload :InMemoryEventStore, 'synapse/event_store/in_memory'
-
-    module Mongo
-      extend ActiveSupport::Autoload
-
-      autoload :CursorDomainEventStream, 'synapse/event_store/mongo/cursor_event_stream'
-      autoload :MongoEventStore, 'synapse/event_store/mongo/event_store'
-      autoload :DocumentPerEventStrategy, 'synapse/event_store/mongo/per_event_strategy'
-      autoload :DocumentPerCommitStrategy, 'synapse/event_store/mongo/per_commit_strategy'
-      autoload :StorageStrategy, 'synapse/event_store/mongo/storage_strategy'
-
-      autoload_at 'synapse/event_store/mongo/template' do
-        autoload :MongoTemplate
-        autoload :DefaultMongoTemplate
-      end
-    end
-  end
-
-  module ProcessManager
-    extend ActiveSupport::Autoload
-
-    autoload :Correlation
-    autoload :CorrelationResolver
-    autoload :CorrelationSet
-
-    autoload :Process
-  end
-
-  module Repository
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload_at 'synapse/repository/errors' do
-        autoload :AggregateNotFoundError
-        autoload :ConcurrencyError
-        autoload :ConflictingAggregateVersionError
-        autoload :ConflictingModificationError
-      end
-
-      autoload :LockManager
-      autoload :PessimisticLockManager
-
-      autoload_at 'synapse/repository/locking' do
-        autoload :LockingRepository
-        autoload :LockCleaningUnitOfWorkListener
-      end
-
-      autoload :Repository
-    end
-  end
-
-  module Serialization
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload :Converter
-      autoload :ConverterFactory,  'synapse/serialization/converter/factory'
-      autoload :IdentityConverter, 'synapse/serialization/converter/identity'
-
-      autoload_at 'synapse/serialization/errors' do
-        autoload :ConversionError
-        autoload :SerializationError
-        autoload :UnknownSerializedTypeError
-      end
-
-      autoload_at 'synapse/serialization/lazy_object' do
-        autoload :DeserializedObject
-        autoload :LazyObject
-      end
-
-      autoload_at 'synapse/serialization/revision_resolver' do
-        autoload :RevisionResolver
-        autoload :FixedRevisionResolver
-      end
-
-      autoload :SerializedDomainEventData, 'synapse/serialization/message/data'
-      autoload :MessageSerializer, 'synapse/serialization/message/serializer'
-      autoload :SerializedMetadata, 'synapse/serialization/message/metadata'
-      autoload :SerializationAware, 'synapse/serialization/message/serialization_aware'
-      autoload :SerializedObjectCache, 'synapse/serialization/message/serialized_object_cache'
-
-      autoload_at 'synapse/serialization/message/serialization_aware_message' do
-        autoload :SerializationAwareEventMessage
-        autoload :SerializationAwareDomainEventMessage
-      end
-
-      autoload_at 'synapse/serialization/message/serialized_message' do
-        autoload :SerializedMessage
-        autoload :SerializedEventMessage
-        autoload :SerializedDomainEventMessage
-      end
-
-      autoload_at 'synapse/serialization/message/serialized_message_builder' do
-        autoload :SerializedMessageBuilder
-        autoload :SerializedEventMessageBuilder
-        autoload :SerializedDomainEventMessageBuilder
-      end
-
-      autoload :Serializer
-      autoload :SerializedObject
-      autoload :SerializedType
-    end
-
-    autoload_at 'synapse/serialization/converter/json' do
-      autoload :JsonToObjectConverter
-      autoload :ObjectToJsonConverter
-    end
-
-    autoload_at 'synapse/serialization/converter/ox' do
-      autoload :XmlToOxDocumentConverter
-      autoload :OxDocumentToXmlConverter
-    end
-
-    autoload :OjSerializer, 'synapse/serialization/serializer/oj'
-    autoload :OxSerializer, 'synapse/serialization/serializer/ox'
-    autoload :MarshalSerializer, 'synapse/serialization/serializer/marshal'
-  end
-
-  module UnitOfWork
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload_at 'synapse/uow/nesting' do
-        autoload :NestableUnitOfWork
-        autoload :OuterCommitUnitOfWorkListener
-      end
-
-      autoload :StorageListener, 'synapse/uow/storage_listener'
-      autoload :TransactionManager, 'synapse/uow/transaction_manager'
-      autoload :UnitOfWork, 'synapse/uow/uow'
-      autoload :UnitOfWorkFactory, 'synapse/uow/factory'
-      autoload :UnitOfWorkListener, 'synapse/uow/listener'
-      autoload :UnitOfWorkListenerCollection, 'synapse/uow/listener_collection'
-      autoload :UnitOfWorkProvider, 'synapse/uow/provider'
-    end
-  end
-
-  module Upcasting
-    extend ActiveSupport::Autoload
-
-    autoload :SingleUpcaster
-    autoload :Upcaster
-    autoload :UpcasterChain, 'synapse/upcasting/chain'
-
-    autoload_at 'synapse/upcasting/context' do
-      autoload :UpcastingContext
-      autoload :SerializedDomainEventUpcastingContext
-    end
-
-    autoload :UpcastSerializedDomainEventData, 'synapse/upcasting/data'
-  end
-
-  module Wiring
-    extend ActiveSupport::Autoload
-
-    autoload :MessageWiring
-    autoload :Wire
-    autoload :WireRegistry
-  end
-
-  # TODO this is more of an application call
-  ActiveSupport::Autoload.eager_autoload!
-
-  # Setup the default identifier factory
-  ActiveSupport.on_load :identifier_factory  do
-    IdentifierFactory.instance = GuidIdentifierFactory.new
-  end
+  eager_autoload do
+    # Common components
+    autoload :Command
+    autoload :Domain
+    autoload :EventBus
+    autoload :Repository
+    autoload :Serialization
+    autoload :UnitOfWork, 'synapse/uow'
+    autoload :Wiring
+  end
+
+  # Optional components
+  autoload :Auditing
+  autoload :EventSourcing
+  autoload :EventStore
+  autoload :Partitioning
+  autoload :ProcessManager
+  autoload :Upcasting
 end

data/test/auditing/data_provider_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+module Synapse
+  module Auditing
+
+    class CommandMetadataProviderTest < Test::Unit::TestCase
+      def test_provide_data_for
+        data = { foo: 0 }
+
+        provider = CommandMetadataProvider.new
+        command = Command::CommandMessage.build do |builder|
+          builder.metadata = data
+        end
+
+        assert_equal data, provider.provide_data_for(command)
+      end
+    end
+
+    class CorrelationDataProviderTest < Test::Unit::TestCase
+      def test_provide_data_for
+        provider = CorrelationDataProvider.new
+        command = Command::CommandMessage.build
+
+        expected = { :command_id => command.id }
+        assert_equal expected, provider.provide_data_for(command)
+      end
+    end
+
+  end
+end

data/test/auditing/dispatch_interceptor_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+module Synapse
+  module Auditing
+
+    class AuditingDispatchInterceptorTest < Test::Unit::TestCase
+      def test_intercept
+        return_value = Object.new
+        chain = Object.new
+        command = Object.new
+        unit = Object.new
+
+        interceptor = AuditingDispatchInterceptor.new
+
+        mock(unit).register_listener(is_a(AuditingUnitOfWorkListener))
+        mock(chain).proceed(command) do
+          return_value
+        end
+
+        assert_equal return_value, interceptor.intercept(command, unit, chain)
+      end
+    end
+
+  end
+end

data/test/auditing/unit_listener_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+module Synapse
+  module Auditing
+
+    class AuditingUnitOfWorkListenerTest < Test::Unit::TestCase
+      def test_on_event_registered
+        data_provider_a = Object.new
+        data_provider_b = Object.new
+
+        command = Object.new
+        data_providers = [data_provider_a, data_provider_b]
+        loggers = []
+
+        listener = AuditingUnitOfWorkListener.new command, data_providers, loggers
+
+        event = Object.new
+
+        data_a = { foo: 0 }
+        data_b = { bar: 1 }
+
+        mock(data_provider_a).provide_data_for(command) { data_a }
+        mock(data_provider_b).provide_data_for(command) { data_b }
+
+        mock(event).and_metadata(data_a.merge(data_b)) { event }
+
+        out = listener.on_event_registered(Object.new, event)
+
+        assert_same event, out
+        assert listener.recorded_events.include? event
+      end
+
+      def test_after_commit
+        logger = Object.new
+
+        command = Object.new
+        return_value = Object.new
+        data_providers = []
+        loggers = [logger]
+        event = Object.new
+
+        mock(logger).on_success(command, return_value, [event])
+
+        listener = AuditingUnitOfWorkListener.new command, data_providers, loggers
+        listener.return_value = return_value
+        listener.recorded_events.push event
+
+        listener.after_commit Object.new
+      end
+
+      def test_on_rollback
+        logger = Object.new
+
+        command = Object.new
+        exception = Exception.new
+        data_providers = []
+        loggers = [logger]
+        event = Object.new
+
+        mock(logger).on_success(command, exception, [event])
+
+        listener = AuditingUnitOfWorkListener.new command, data_providers, loggers
+        listener.recorded_events.push event
+
+        listener.on_rollback Object.new, exception
+      end
+    end
+
+  end
+end

data/test/partitioning/memory_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+module Synapse
+  module Partitioning
+
+    class MemoryQueueTest < Test::Unit::TestCase
+      def test_queuing
+        message = MessageBuilder.build
+
+        queue = Queue.new
+
+        reader = MemoryQueueReader.new queue, :test
+        writer = MemoryQueueWriter.new queue
+
+        count = 0
+
+        Thread.new do
+          reader.subscribe do |receipt|
+            assert_equal message, receipt.packed
+            assert_equal :test, receipt.queue_name
+
+            count = count.next
+          end
+        end
+
+        writer.put_message message, message
+        writer.put_message message, message
+
+        wait_until { count == 2 }
+      end
+    end
+
+  end
+end

data/test/partitioning/packing/json_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+
+module Synapse
+  module Partitioning
+
+    class JsonPackingTest < Test::Unit::TestCase
+      def setup
+        @serializer = Serialization::MarshalSerializer.new
+        @packer = JsonMessagePacker.new @serializer
+        @unpacker = JsonMessageUnpacker.new @serializer
+      end
+
+      def test_packing
+        message = Domain::DomainEventMessage.build do |builder|
+          builder.metadata = { foo: 0 }
+          builder.payload = { bar: 1 }
+          builder.aggregate_id = '123'
+          builder.sequence_number = 1
+        end
+
+        packed = @packer.pack_message message
+        unpacked = @unpacker.unpack_message packed
+
+        assert_equal message.id, unpacked.id
+        assert_equal message.metadata, unpacked.metadata
+        assert_equal message.payload, unpacked.payload
+        assert_equal message.timestamp.to_i, unpacked.timestamp.to_i
+        assert_equal message.aggregate_id, unpacked.aggregate_id
+        assert_equal message.sequence_number, unpacked.sequence_number
+      end
+
+      def test_type_packing
+        [Command::CommandMessage, Domain::EventMessage, Domain::DomainEventMessage].each do |type|
+          message = type.build
+          packed = @packer.pack_message message
+          unpacked = @unpacker.unpack_message packed
+
+          assert type === unpacked
+        end
+      end
+
+      def test_unknown_type
+        message = Message.build
+
+        assert_raise ArgumentError do
+          @packer.pack_message message
+        end
+
+        packed = {
+          message_type: :message
+        }
+        packed = JSON.dump packed
+
+        assert_raise ArgumentError do
+          @unpacker.unpack_message packed
+        end
+      end
+    end
+
+  end
+end

data/test/test_ext.rb

@@ -0,0 +1,14 @@
+class Test::Unit::TestCase
+  # Blocks until a condition is met or a timeout occurs
+  #
+  # @param [Integer] timeout In seconds
+  # @param [Float] retry_interval In seconds
+  # @return [undefined]
+  def wait_until(timeout = 2, retry_interval = 0.1, &block)
+    start = Time.now
+    until !!block.call
+      raise if (Time.now - start).to_i >= timeout
+      sleep retry_interval
+    end
+  end
+end

data/test/test_helper.rb

@@ -14,6 +14,10 @@ require 'rr'
 require 'timecop'
 require 'synapse'
 
+require 'test_ext'
+
 class Test::Unit::TestCase
   include RR::Adapters::TestUnit
 end
+
+ActiveSupport::Autoload.eager_autoload!