synapse-mongo 0.1.1

data/lib/synapse-mongo.rb

@@ -0,0 +1,24 @@
+require 'active_support'
+require 'mongo'
+require 'synapse'
+
+require 'synapse/mongo/version'
+
+module Synapse
+  module Common
+    # Utility classes used by Mongo components
+    module Mongo
+      extend ActiveSupport::Autoload
+
+      autoload :BaseTemplate
+    end
+  end
+
+  module EventStore
+    autoload :Mongo
+  end
+
+  module Serialization
+    autoload :OrderedHashToHashConverter, 'synapse/serialization/converter/bson'
+  end
+end

data/lib/synapse/common/mongo/base_template.rb

@@ -0,0 +1,40 @@
+module Synapse
+  module Common
+    module Mongo
+      # Represents a mechanism for accessing collections required by a component
+      # @abstract
+      class BaseTemplate
+        # @return [String] Name of the database to use
+        attr_accessor :database_name
+
+        # @return [String] Username to authenticate with (optional)
+        attr_accessor :username
+
+        # @return [String] Password to authenticate with (optional)
+        attr_accessor :password
+
+        # @param [Mongo::MongoClient] client
+        # @return [undefined]
+        def initialize(client)
+          @client = client
+          @database_name = 'synapse'
+        end
+
+      protected
+
+        # @return [Mongo::DB]
+        def database
+          unless @database
+            @database = @client.db @database_name
+
+            if @username and @password
+              @database.authenticate @username, @password
+            end
+          end
+
+          @database
+        end
+      end # BaseTemplate
+    end # Mongo
+  end # Common
+end

data/lib/synapse/event_store/mongo.rb

@@ -0,0 +1,8 @@
+require 'synapse/event_store/mongo/cursor_event_stream'
+require 'synapse/event_store/mongo/event_store'
+
+require 'synapse/event_store/mongo/storage_strategy'
+require 'synapse/event_store/mongo/per_commit_strategy'
+require 'synapse/event_store/mongo/per_event_strategy'
+
+require 'synapse/event_store/mongo/template'

data/lib/synapse/event_store/mongo/cursor_event_stream.rb

@@ -0,0 +1,63 @@
+module Synapse
+  module EventStore
+    module Mongo
+      # TODO Document me
+      class CursorDomainEventStream < Domain::DomainEventStream
+        # @param [StorageStrategy] storage_strategy
+        # @param [Mongo::Cursor] cursor
+        # @param [Array] last_snapshot_commit
+        # @param [Object] aggregate_id
+        # @return [undefined]
+        def initialize(storage_strategy, cursor, last_snapshot_commit, aggregate_id)
+          @storage_strategy = storage_strategy
+          @cursor = cursor
+          @aggregate_id = aggregate_id
+
+          if last_snapshot_commit
+            # Current batch is an enumerator
+            @current_batch = last_snapshot_commit.each
+          else
+            @current_batch = [].each
+          end
+
+          initialize_next_event
+        end
+
+        # @return [Boolean]
+        def end?
+          @next.nil?
+        end
+
+        # @return [DomainEventMessage]
+        def next_event
+          @next.tap do
+            initialize_next_event
+          end
+        end
+
+        # @return [DomainEventMessage]
+        def peek
+          @next
+        end
+
+      private
+
+        # @return [undefined]
+        def initialize_next_event
+          begin
+            @next = @current_batch.next
+          rescue StopIteration
+            if @cursor.has_next?
+              document = @cursor.next
+              @current_batch = @storage_strategy.extract_events(document, @aggregate_id).each
+
+              retry
+            else
+              @next = nil
+            end
+          end
+        end
+      end # CursorDomainEventStream
+    end
+  end
+end

data/lib/synapse/event_store/mongo/event_store.rb

@@ -0,0 +1,88 @@
+module Synapse
+  module EventStore
+    module Mongo
+      # Implementation of an event store backed by a Mongo database
+      class MongoEventStore < SnapshotEventStore
+        # @param [MongoTemplate] template
+        # @param [StorageStrategy] storage_strategy
+        # @return [undefined]
+        def initialize(template, storage_strategy)
+          @storage_strategy = storage_strategy
+          @template = template
+        end
+
+        # @return [undefined]
+        def ensure_indexes
+          @storage_strategy.ensure_indexes
+        end
+
+        # @raise [EventStoreError] If an error occurs while reading the stream from the store
+        # @param [String] type_identifier Type descriptor of the aggregate to retrieve
+        # @param [Object] aggregate_id
+        # @return [DomainEventStream]
+        def read_events(type_identifier, aggregate_id)
+          first_sequence_number = -1
+
+          last_snapshot_commit = load_last_snapshot type_identifier, aggregate_id
+          if last_snapshot_commit and last_snapshot_commit.size > 0
+            first_sequence_number = last_snapshot_commit[0].sequence_number
+          end
+
+          first_sequence_number = first_sequence_number.next
+
+          cursor = @storage_strategy.fetch_events type_identifier, aggregate_id, first_sequence_number
+
+          unless last_snapshot_commit or cursor.has_next?
+            raise StreamNotFoundError.new type_identifier, aggregate_id
+          end
+
+          CursorDomainEventStream.new @storage_strategy, cursor, last_snapshot_commit, aggregate_id
+        end
+
+        # @raise [EventStoreError] If an error occurs while appending the stream to the store
+        # @param [String] type_identifier Type descriptor of the aggregate to append to
+        # @param [DomainEventStream] stream
+        # @return [undefined]
+        def append_events(type_identifier, stream)
+          events = stream.to_a
+          documents = @storage_strategy.create_documents type_identifier, events
+
+          begin
+            @template.event_collection.insert documents
+          rescue ::Mongo::OperationFailure => exception
+            if exception.error_code == 11000
+              raise Repository::ConcurrencyError,
+                'Event for this aggregate and sequence number already present'
+            end
+
+            raise ex
+          end
+        end
+
+        # @raise [EventStoreError] If an error occurs while appending the event to the store
+        # @param [String] type_identifier Type descriptor of the aggregate to append to
+        # @param [DomainEventMessage] snapshot_event
+        # @return [undefined]
+        def append_snapshot_event(type_identifier, snapshot_event)
+          documents = @storage_strategy.create_documents type_identifier, [snapshot_event]
+          @template.snapshot_collection.insert documents
+        end
+
+      private
+
+        # @param [String] type_identifier Type descriptor of the aggregate to retrieve
+        # @param [Object] aggregate_id
+        def load_last_snapshot(type_identifier, aggregate_id)
+          cursor = @storage_strategy.fetch_last_snapshot type_identifier, aggregate_id
+
+          unless cursor.has_next?
+            return
+          end
+
+          first = cursor.next_document
+          @storage_strategy.extract_events first, aggregate_id
+        end
+      end # MongoEventStore
+    end # Mongo
+  end # EventStore
+end # Synapse

data/lib/synapse/event_store/mongo/per_commit_strategy.rb

@@ -0,0 +1,253 @@
+module Synapse
+  module EventStore
+    module Mongo
+      # Storage strategy that stores all events in a commit operation in a single document
+      #
+      # Since Mongo doesn't support transactions, this can be used as a substitute to guarantee
+      # atomic storage of events. The only downside is that it may be harder to query events
+      # from the event store.
+      #
+      # Performance also seems to be better using this strategy
+      class DocumentPerCommitStrategy < StorageStrategy
+        # @param [String] type_identifier Type identifier for the aggregate
+        # @param [Array] events Domain events to be committed
+        # @return [Array]
+        def create_documents(type_identifier, events)
+          document = CommitDocument.new
+          document.from_events(type_identifier, events, @serializer).to_hash
+        end
+
+        # @param [Hash] hash
+        # @param [Object] aggregate_id
+        # @return [Array]
+        def extract_events(hash, aggregate_id)
+          document = CommitDocument.new
+          document.from_hash(hash).to_events(aggregate_id, @serializer, @upcaster_chain)
+        end
+
+        # Mongo document that represents a commit containing one or more events
+        class CommitDocument
+          # @return [Object]
+          attr_reader :aggregate_id
+
+          # @param [String] type_identifier
+          # @param [Array] events
+          # @param [Serializer] serializer
+          # @return [CommitDocument]
+          def from_events(type_identifier, events, serializer)
+            first_event = events.first
+            last_event = events.last
+
+            @aggregate_type = type_identifier
+            @aggregate_id = first_event.aggregate_id.to_s
+            @first_sequence_number = first_event.sequence_number
+            @last_sequence_number = last_event.sequence_number
+            @first_timestamp = first_event.timestamp
+            @last_timestamp = last_event.timestamp
+
+            @events = Array.new
+            events.each do |event|
+              event_document = EventDocument.new
+              event_document.from_event event, serializer
+
+              @events.push event_document
+            end
+
+            self
+          end
+
+          # @param [Hash] hash
+          # @return [CommitDocument]
+          def from_hash(hash)
+            hash.symbolize_keys!
+
+            @aggregate_id = hash.fetch :aggregate_id
+            @aggregate_type = hash.fetch :aggregate_type
+            @first_sequence_number = hash.fetch :first_sequence_number
+            @last_sequence_number = hash.fetch :last_sequence_number
+            @first_timestamp = hash.fetch :first_timestamp
+            @last_timestamp = hash.fetch :last_timestamp
+
+            @events = Array.new
+
+            event_hashes = hash.fetch :events
+            event_hashes.each do |event_hash|
+              event_document = EventDocument.new
+              event_document.from_hash event_hash
+
+              @events.push event_document
+            end
+
+            self
+          end
+
+          # @return [Hash]
+          def to_hash
+            events = Array.new
+            @events.each do |event|
+              events.push event.to_hash
+            end
+
+            { aggregate_id: @aggregate_id,
+              aggregate_type: @aggregate_type,
+              # Allows us to use the same query to filter events as DocumentPerEvent
+              sequence_number: @first_sequence_number,
+              first_sequence_number: @first_sequence_number,
+              last_sequence_number: @last_sequence_number,
+              # Allows us to use the same query to filter events as DocumentPerEvent
+              timestamp: @first_timestamp,
+              first_timestamp: @first_timestamp,
+              last_timestamp: @last_timestamp,
+              events: events }
+          end
+
+          # @param [Object] aggregate_id The actual aggregate identifier used to query the evnet store
+          # @param [Serializer] serializer
+          # @param [UpcasterChain] upcaster_chain
+          # @return [Array]
+          def to_events(aggregate_id, serializer, upcaster_chain)
+            events = Array.new
+
+            @events.each do |event_document|
+              event_data = DocumentDomainEventData.new aggregate_id, event_document
+              context = Upcasting::SerializedDomainEventUpcastingContext.new event_data, aggregate_id, serializer
+
+              upcast_objects = upcaster_chain.upcast event_document.payload, context
+              upcast_objects.each do |upcast_object|
+                upcast_data = Upcasting::UpcastSerializedDomainEventData.new event_data, aggregate_id, upcast_object
+
+                builder = Serialization::SerializedDomainEventMessageBuilder.new
+
+                # Prevent duplicate serialization of metadata if it was accessed during upcasting
+                metadata = context.serialized_metadata
+                if metadata.deserialized?
+                  builder.metadata = Serialization::DeserializedObject.new metadata.deserialized
+                end
+
+                builder.from_data upcast_data, serializer
+
+                events.push builder.build
+              end
+            end
+
+            events
+          end
+        end # CommitDocument
+
+        # Mongo document that represents a single event as part of a commit document
+        class EventDocument
+          # @return [String]
+          attr_reader :id
+
+          # @return [Time]
+          attr_reader :timestamp
+
+          # @return [Integer]
+          attr_reader :sequence_number
+
+          # @return [SerializedObject]
+          def metadata
+            Serialization::SerializedMetadata.new @metadata, @metadata.class
+          end
+
+          # @return [SerializedObject]
+          def payload
+            Serialization::SerializedObject.new @payload, @payload.class,
+              Serialization::SerializedType.new(@payload_type, @payload_revision)
+          end
+
+          # @param [EventMessage] event
+          # @param [Serializer] serializer
+          # @return [EventDocument]
+          def from_event(event, serializer)
+            serialization_target = String
+            if serializer.can_serialize_to? Hash
+              serialization_target = Hash
+            end
+
+            serialized_metadata = serializer.serialize_metadata event, serialization_target
+            serialized_payload = serializer.serialize_payload event, serialization_target
+
+            @id = event.id
+            @metadata = serialized_metadata.content
+            @payload = serialized_payload.content
+            @payload_type = serialized_payload.type.name
+            @payload_revision = serialized_payload.type.revision
+            @timestamp = event.timestamp
+            @sequence_number = event.sequence_number
+
+            self
+          end
+
+          # @param [Hash] hash
+          # @return [EventDocument]
+          def from_hash(hash)
+            hash.symbolize_keys!
+
+            @id = hash.fetch :id
+            @metadata = hash.fetch :metadata
+            @payload = hash.fetch :payload
+            @payload_type = hash.fetch :payload_type
+            @payload_revision = hash.fetch :payload_revision
+            @timestamp = hash.fetch :timestamp
+            @sequence_number = hash.fetch :sequence_number
+
+            self
+          end
+
+          # @return [Hash]
+          def to_hash
+            { id: @id,
+              metadata: @metadata,
+              payload: @payload,
+              payload_type: @payload_type,
+              payload_revision: @payload_revision,
+              timestamp: @timestamp,
+              sequence_number: @sequence_number }
+          end
+        end # EventDocument
+
+        # Serialized domain event data from an event document
+        class DocumentDomainEventData < Serialization::SerializedDomainEventData
+          # @param [Object] aggregate_id
+          # @param [EventDocument] event_document
+          # @return [undefined]
+          def initialize(aggregate_id, event_document)
+            @aggregate_id = aggregate_id
+            @event_document = event_document
+          end
+
+          # @return [String]
+          def id
+            @event_document.id
+          end
+
+          # @return [SerializedObject]
+          def metadata
+            @event_document.metadata
+          end
+
+          # @return [SerializedObject]
+          def payload
+            @event_document.payload
+          end
+
+          # @return [Time]
+          def timestamp
+            @event_document.timestamp
+          end
+
+          # @return [Object]
+          def aggregate_id
+            @aggregate_id
+          end
+
+          # @return [Integer]
+          def sequence_number
+            @event_document.sequence_number
+          end
+        end # DocumentDomainEventData
+      end # DocumentPerCommitStrategy
+    end # Mongo
+  end # EventStore
+end # Synapse

data/lib/synapse/event_store/mongo/per_event_strategy.rb

@@ -0,0 +1,143 @@
+module Synapse
+  module EventStore
+    module Mongo
+      # Storage strategy that stores each event as its own document
+      class DocumentPerEventStrategy < StorageStrategy
+        # @param [String] type_identifier Type identifier for the aggregate
+        # @param [Array] events Domain events to be committed
+        # @return [Array]
+        def create_documents(type_identifier, events)
+          documents = Array.new
+
+          events.each do |event|
+            document = EventDocument.new
+            document.from_event event, type_identifier, @serializer
+
+            documents.push document.to_hash
+          end
+
+          documents
+        end
+
+        # @param [Hash] hash
+        # @param [Object] aggregate_id
+        # @return [Array]
+        def extract_events(hash, aggregate_id)
+          document = EventDocument.new
+          document.from_hash(hash).to_events(aggregate_id, @serializer, @upcaster_chain)
+        end
+
+        # Mongo document that represents a single domain event
+        class EventDocument < Serialization::SerializedDomainEventData
+          # @return [String]
+          attr_reader :id
+
+          # @return [Time]
+          attr_reader :timestamp
+
+          # @return [Object]
+          attr_reader :aggregate_id
+
+          # @return [Integer]
+          attr_reader :sequence_number
+
+          # @param [SerializedObject]
+          def metadata
+            Serialization::SerializedMetadata.new @metadata, @metadata.class
+          end
+
+          # @param [SerializedObject]
+          def payload
+            Serialization::SerializedObject.new @payload, @payload.class,
+              Serialization::SerializedType.new(@payload_type, @payload_revision)
+          end
+
+          # @param [DomainEventMessage] event
+          # @param [String] type_identifier
+          # @param [Serializer] serializer
+          # @return [EventDocument]
+          def from_event(event, type_identifier, serializer)
+            serialization_target = String
+            if serializer.can_serialize_to? Hash
+              serialization_target = Hash
+            end
+
+            serialized_metadata = serializer.serialize_metadata event, serialization_target
+            serialized_payload = serializer.serialize_payload event, serialization_target
+
+            @id = event.id
+            @metadata = serialized_metadata.content
+            @payload = serialized_payload.content
+            @payload_type = serialized_payload.type.name
+            @payload_revision = serialized_payload.type.revision
+            @timestamp = event.timestamp
+            @aggregate_id = event.aggregate_id
+            @aggregate_type = type_identifier
+            @sequence_number = event.sequence_number
+
+            self
+          end
+
+          # @param [Hash] hash
+          # @return [EventDocument]
+          def from_hash(hash)
+            hash.symbolize_keys!
+
+            @id = hash.fetch :_id
+            @metadata = hash.fetch :metadata
+            @payload = hash.fetch :payload
+            @payload_type = hash.fetch :payload_type
+            @payload_revision = hash.fetch :payload_revision
+            @timestamp = hash.fetch :timestamp
+            @aggregate_id = hash.fetch :aggregate_id
+            @aggregate_type = hash.fetch :aggregate_type
+            @sequence_number = hash.fetch :sequence_number
+
+            self
+          end
+
+          # @return [Hash]
+          def to_hash
+            { _id: @id,
+              metadata: @metadata,
+              payload: @payload,
+              payload_type: @payload_type,
+              payload_revision: @payload_revision,
+              timestamp: @timestamp,
+              aggregate_id: @aggregate_id,
+              aggregate_type: @aggregate_type,
+              sequence_number: @sequence_number }
+          end
+
+          # @param [Object] aggregate_id
+          # @param [Serializer] serializer
+          # @param [UpcasterChain] upcaster_chain
+          # @return [Array]
+          def to_events(aggregate_id, serializer, upcaster_chain)
+            events = Array.new
+
+            context = Upcasting::SerializedDomainEventUpcastingContext.new self, aggregate_id, serializer
+            upcast_objects = upcaster_chain.upcast payload, context
+            upcast_objects.each do |upcast_object|
+              upcast_data = Upcasting::UpcastSerializedDomainEventData.new self, aggregate_id, upcast_object
+
+              builder = Serialization::SerializedDomainEventMessageBuilder.new
+
+              # Prevent duplicate serialization of metadata if it was accessed during upcasting
+              metadata = context.serialized_metadata
+              if metadata.deserialized?
+                builder.metadata = Serialization::DeserializedObject.new metadata.deserialized
+              end
+
+              builder.from_data upcast_data, serializer
+
+              events.push builder.build
+            end
+
+            events
+          end
+        end # EventDocument
+      end # DocumentPerEventStrategy
+    end # Mongo
+  end # EventStore
+end # Synapse

data/lib/synapse/event_store/mongo/storage_strategy.rb

@@ -0,0 +1,113 @@
+module Synapse
+  module EventStore
+    module Mongo
+      # Represents a mechanism used to structure how events are stored in the database
+      # @abstract
+      class StorageStrategy
+        # @param [MongoTemplate] template
+        # @param [Serializer] serializer
+        # @param [UpcasterChain] upcaster_chain
+        # @return [undefined]
+        def initialize(template, serializer, upcaster_chain)
+          @template = template
+          @serializer = Serialization::MessageSerializer.new serializer
+          @upcaster_chain = upcaster_chain
+        end
+
+        # Creates documents that will represent the events being committed to the event store
+        #
+        # @abstract
+        # @param [String] type_identifier Type identifier for the aggregate
+        # @param [Array] events Domain events to be committed
+        # @return [Array]
+        def create_documents(type_identifier, events); end
+
+        # Extracts individual event messages from the given document
+        #
+        # The given aggregate identifier is passed so that event messages can have the actual
+        # identifier object instead of the serialized aggregate identifier.
+        #
+        # @abstract
+        # @param [Hash] document
+        # @param [Object] aggregate_id
+        # @return [Array]
+        def extract_events(document, aggregate_id); end
+
+        # Aliases of the Mongo constants for ascending and descending
+        ASCENDING = ::Mongo::ASCENDING
+        DESCENDING = ::Mongo::DESCENDING
+
+        # Provides a cursor for accessing all events for an aggregate with the given identifier
+        # and type identifier, with a sequence number equal to or greater than the given first
+        # sequence number
+        #
+        # The returned documents should be ordered chronologically, typically by using the
+        # sequence number.
+        #
+        # @param [String] type_identifier
+        # @param [Object] aggregate_id
+        # @param [Integer] first_sequence_number
+        # @return [Mongo::Cursor]
+        def fetch_events(type_identifier, aggregate_id, first_sequence_number)
+          filter = {
+            aggregate_id: aggregate_id,
+            aggregate_type: type_identifier,
+            sequence_number: {
+              '$gte' => first_sequence_number
+            }
+          }
+
+          sort = {
+            sequence_number: ASCENDING
+          }
+
+          @template.event_collection.find(filter).sort(sort)
+        end
+
+        # Finds the document containing the most recent snapshot event for an aggregate with the
+        # given identifier and type identifier
+        #
+        # @param [String] type_identifier
+        # @param [Object] aggregate_id
+        # @return [Mongo::Cursor]
+        def fetch_last_snapshot(type_identifier, aggregate_id)
+          filter = {
+            aggregate_id: aggregate_id,
+            aggregate_type: type_identifier
+          }
+
+          sort = {
+            sequence_number: DESCENDING
+          }
+
+          @template.snapshot_collection.find(filter).sort(sort).limit(1)
+        end
+
+        # Ensures that the correct indexes are in place
+        # @return [undefined]
+        def ensure_indexes
+          options = {
+            name: 'unique_aggregate_index',
+            unique: true
+          }
+
+          spec = {
+            aggregate_id: ASCENDING,
+            aggregate_type: ASCENDING,
+            sequence_number: ASCENDING
+          }
+
+          @template.event_collection.ensure_index spec, options
+
+          spec = {
+            aggregate_id: ASCENDING,
+            aggregate_type: ASCENDING,
+            sequence_number: DESCENDING
+          }
+
+          @template.snapshot_collection.ensure_index spec, options
+        end
+      end # StorageStrategy
+    end # Mongo
+  end # EventStore
+end # Synapse

data/lib/synapse/event_store/mongo/template.rb

@@ -0,0 +1,33 @@
+module Synapse
+  module EventStore
+    module Mongo
+      # Template for accessing collections needed by the event store
+      class Template < Common::Mongo::BaseTemplate
+        # @return [String] Name of the collection containing domain events
+        attr_accessor :event_collection_name
+
+        # @return [String] Name of the collection containing snapshot events
+        attr_accessor :snapshot_collection_name
+
+        # @param [Mongo::MongoClient] client
+        # @return [undefined]
+        def initialize(client)
+          super
+
+          @event_collection_name = 'domain_events'
+          @snapshot_collection_name = 'snapshot_events'
+        end
+
+        # @return [Mongo::Collection]
+        def event_collection
+          database.collection @event_collection_name
+        end
+
+        # @return [Mongo::Collection]
+        def snapshot_collection
+          database.collection @snapshot_collection_name
+        end
+      end # MongoTemplate
+    end # Mongo
+  end # EventStore
+end # Synapse

data/lib/synapse/mongo/version.rb

@@ -0,0 +1,5 @@
+module Synapse
+  module Mongo
+    VERSION = '0.1.1'
+  end
+end

data/lib/synapse/serialization/converter/bson.rb

@@ -0,0 +1,26 @@
+module Synapse
+  module Serialization
+    # Converter that converts an ordered hash from BSON into a regular Ruby hash
+    class OrderedHashToHashConverter
+      include Converter
+
+      converts BSON::OrderedHash, Hash
+
+      # @param [Object] original
+      # @return [Object]
+      def convert_content(original)
+        converted = Hash.new
+
+        original.each do |key, value|
+          if value.is_a? BSON::OrderedHash
+            value = convert_content value
+          end
+
+          converted[key] = value
+        end
+
+        converted
+      end
+    end
+  end
+end

data/test/common/mongo/base_template_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+module Synapse
+  module Common
+    module Mongo
+
+      class BaseTemplateTest < Test::Unit::TestCase
+        def test_database
+          client = Object.new
+          database = Object.new
+
+          database_name = 'test_database'
+          username = 'test_username'
+          password = 'test_password'
+
+          mock(client).db(database_name) do
+            database
+          end
+
+          mock(database).authenticate(username, password)
+
+          template = BaseTemplate.new client
+          template.database_name = database_name
+          template.username = username
+          template.password = password
+
+          template.send :database
+          # Additional calls to database should return the same database
+          template.send :database
+        end
+      end
+
+    end
+  end
+end

data/test/event_store/mongo/event_store_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+module Synapse
+  module EventStore
+    module Mongo
+
+      class MongoEventStoreTest < Test::Unit::TestCase
+        def test_integration
+          client = ::Mongo::MongoClient.new
+          template = Template.new client
+
+          serializer = Serialization::MarshalSerializer.new
+          upcaster_chain = Upcasting::UpcasterChain.new serializer.converter_factory
+
+          [DocumentPerCommitStrategy, DocumentPerEventStrategy].each do |type|
+            strategy = type.new template, serializer, upcaster_chain
+            test_integration_with template, strategy
+          end
+
+        end
+
+      private
+
+        def test_integration_with(template, strategy)
+          store = MongoEventStore.new template, strategy
+          store.ensure_indexes
+
+          type_identifier = 'TestAggregate'
+
+          metadata = {
+            foo: 0,
+            bar: 1
+          }
+          payload = TestEvent.new 1, 2
+          aggregate_id = SecureRandom.uuid
+
+
+          x = 0
+
+          # Create two sets of 50 events each
+          # After this, we'll add an artificial snapshot at seq num 49
+          2.times do
+            events = Array.new
+
+            50.times do
+              events.push create_event metadata, payload, aggregate_id, x
+              x = x.next
+            end
+
+            append_stream = Domain::SimpleDomainEventStream.new events
+            store.append_events type_identifier, append_stream
+          end
+
+          read_stream = store.read_events type_identifier, aggregate_id
+          read_array = read_stream.to_a
+
+          assert_equal 100, read_array.count
+
+          snapshot = create_event metadata, payload, aggregate_id, 49
+          store.append_snapshot_event type_identifier, snapshot
+
+          read_stream = store.read_events type_identifier, aggregate_id
+          read_array = read_stream.to_a
+
+          assert_equal 51, read_array.count
+        end
+
+        def create_event(metadata, payload, aggregate_id, sequence_number)
+          Domain::DomainEventMessage.build do |builder|
+            builder.metadata = metadata
+            builder.payload = payload
+            builder.aggregate_id = aggregate_id
+            builder.sequence_number = sequence_number
+          end
+        end
+      end
+
+      class TestEvent
+        attr_accessor :foo
+        attr_accessor :bar
+
+        def initialize(foo, bar)
+          @foo, @bar = foo, bar
+        end
+      end
+
+    end
+  end
+end

data/test/serialization/converter/bson_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+    class OrderedHashToHashConverterTest < Test::Unit::TestCase
+      def test_convert
+        converter = OrderedHashToHashConverter.new
+
+        assert_equal BSON::OrderedHash, converter.source_type
+        assert_equal Hash, converter.target_type
+
+        source = BSON::OrderedHash.new
+        source[:foo] = 0
+        source[:bar] = BSON::OrderedHash.new
+        source[:bar][:baz] = 1
+
+        target = {
+          :foo => 0,
+          :bar => {
+            :baz => 1
+          }
+        }
+
+        assert_equal target, converter.convert_content(source)
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter '/test/'
+end
+
+require 'pp'
+require 'test/unit'
+require 'rr'
+require 'synapse-mongo'
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: synapse-mongo
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Ian Unruh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: synapse-core
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: MongoDB implementations for the Synapse CQRS framework
+email: ianunruh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/synapse-mongo.rb
+- lib/synapse/mongo/version.rb
+- lib/synapse/event_store/mongo/cursor_event_stream.rb
+- lib/synapse/event_store/mongo/event_store.rb
+- lib/synapse/event_store/mongo/storage_strategy.rb
+- lib/synapse/event_store/mongo/template.rb
+- lib/synapse/event_store/mongo/per_commit_strategy.rb
+- lib/synapse/event_store/mongo/per_event_strategy.rb
+- lib/synapse/event_store/mongo.rb
+- lib/synapse/common/mongo/base_template.rb
+- lib/synapse/serialization/converter/bson.rb
+- test/test_helper.rb
+- test/event_store/mongo/event_store_test.rb
+- test/common/mongo/base_template_test.rb
+- test/serialization/converter/bson_test.rb
+homepage: https://github.com/iunruh/synapse-mongo
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: MongoDB implementations for the Synapse CQRS framework
+test_files: []
+has_rdoc: