synapse-core 0.1.2

data/test/repository/locking_test.rb

@@ -0,0 +1,101 @@
+require 'test_helper'
+
+module Synapse
+  module Repository
+    class LockingRepositoryTest < Test::Unit::TestCase
+      def setup
+        @event_bus = Object.new
+        @lock_manager = Object.new
+        @storage_listener = Object.new
+        @unit_provider = UnitOfWork::UnitOfWorkProvider.new
+
+        @unit = UnitOfWork::UnitOfWork.new @unit_provider
+        @unit.start
+
+        # I herd you like dependencies
+        @repository = TestRepository.new @lock_manager
+        @repository.event_bus = @event_bus
+        @repository.storage_listener = @storage_listener
+        @repository.unit_provider = @unit_provider
+      end
+
+      def test_add
+        mock(@lock_manager).obtain_lock(123)
+        mock(@lock_manager).release_lock(123)
+
+        aggregate = TestAggregateRoot.new 123, nil
+
+        mock(@storage_listener).store(aggregate)
+
+        @repository.add aggregate
+        @unit.commit
+      end
+
+      def test_add_incompatible_aggregate
+        mock(@lock_manager).obtain_lock(123)
+        mock(@lock_manager).release_lock(123)
+
+        aggregate = OpenStruct.new
+        aggregate.id = 123
+
+        assert_raises ArgumentError do
+          @repository.add aggregate
+        end
+      end
+
+      def test_add_versioned
+        mock(@lock_manager).obtain_lock(123)
+        mock(@lock_manager).release_lock(123)
+
+        aggregate = TestAggregateRoot.new 123, 0
+
+        assert_raises ArgumentError do
+          @repository.add aggregate
+        end
+      end
+
+      def test_load_version_ahead
+        mock(@lock_manager).obtain_lock(123)
+        mock(@lock_manager).release_lock(123)
+
+        @repository.aggregate = TestAggregateRoot.new 123, 1
+
+        assert_raises ConflictingAggregateVersionError do
+          @repository.load 123, 0
+        end
+      end
+    end
+
+    class TestAggregateRoot
+      include Domain::AggregateRoot
+
+      def initialize(id, version)
+        @id, @version = id, version
+      end
+    end
+
+    class TestRepository < LockingRepository
+      attr_accessor :aggregate, :storage_listener
+
+    protected
+
+      def perform_load(aggregate_id, expected_version)
+        unless @aggregate
+          raise AggregateNotFoundError
+        end
+
+        assert_version_expected @aggregate, expected_version
+
+        @aggregate
+      end
+
+      def aggregate_type
+        TestAggregateRoot
+      end
+
+      def storage_listener
+        @storage_listener
+      end
+    end
+  end
+end

data/test/serialization/converter/factory_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+
+    class ConverterFactoryTest < Test::Unit::TestCase
+
+      def setup
+        @factory = ConverterFactory.new
+      end
+
+      def test_identity
+        assert @factory.has_converter?(String, String)
+        assert @factory.converter(String, String).is_a?(IdentityConverter)
+      end
+
+      def test_converter
+        refute @factory.has_converter?(Object, String)
+
+        assert_raise ConversionError do
+          @factory.converter(Object, String)
+        end
+
+        converter = ObjectToJsonConverter.new
+        @factory.register converter
+
+        assert @factory.has_converter?(Object, String)
+        assert_equal converter, @factory.converter(Object, String)
+      end
+    end
+
+  end
+end

data/test/serialization/converter/identity_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+    class IdentityConverterTest < Test::Unit::TestCase
+      def test_conversion
+        converter = IdentityConverter.new Object
+        content = Hash.new
+
+        assert_equal Object, converter.source_type
+        assert_equal Object, converter.target_type
+        assert content === converter.convert(content)
+        assert content === converter.convert_content(content)
+      end
+    end
+  end
+end

data/test/serialization/converter/json_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+    class JsonToObjectConverterTest < Test::Unit::TestCase
+      def test_convert
+        converter = JsonToObjectConverter.new
+
+        assert_equal String, converter.source_type
+        assert_equal Object, converter.target_type
+
+        output = converter.convert_content '{}'
+
+        assert_equal Hash, output.class
+      end
+    end
+
+    class ObjectToJsonConverterTest < Test::Unit::TestCase
+      def test_convert
+        converter = ObjectToJsonConverter.new
+
+        assert_equal Object, converter.source_type
+        assert_equal String, converter.target_type
+
+        output = converter.convert_content Hash.new
+
+        assert_equal String, output.class
+      end
+    end
+  end
+end

data/test/serialization/converter/ox_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+    class OxDocumentToXmlConverterTest < Test::Unit::TestCase
+      def setup
+        skip 'Ox not supported on JRuby' if defined? JRUBY_VERSION
+      end
+
+      def test_convert
+        converter = OxDocumentToXmlConverter.new
+
+        assert_equal Ox::Document, converter.source_type
+        assert_equal String, converter.target_type
+
+        input = Ox::Document.new
+        output = converter.convert_content input
+
+        assert_equal String, output.class
+      end
+    end
+
+    class XmlToOxDocumentConverterTest < Test::Unit::TestCase
+      def setup
+        skip 'Ox not supported on JRuby' if defined? JRUBY_VERSION
+      end
+
+      def test_convert
+        converter = XmlToOxDocumentConverter.new
+
+        assert_equal String, converter.source_type
+        assert_equal Ox::Document, converter.target_type
+
+        output = converter.convert_content '<?xml?>'
+
+        assert_equal Ox::Document, output.class
+      end
+    end
+  end
+end

data/test/serialization/fixtures.rb

@@ -0,0 +1,17 @@
+module Synapse
+  module Serialization
+    class TestEvent
+      attr_reader :a, :b
+
+      def initialize(a, b)
+        @a, @b = a, b
+      end
+
+      def ==(other)
+        self.class === other and
+          other.a == @a and
+          other.b == @b
+      end
+    end
+  end
+end

data/test/serialization/lazy_object_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+require 'serialization/fixtures'
+
+module Synapse
+  module Serialization
+    class LazyObjectTest < Test::Unit::TestCase
+      def test_deserialize_once
+        serializer = MarshalSerializer.new
+        event = TestEvent.new 'a', 'b'
+
+        serialized = serializer.serialize event, String
+
+        lazy = LazyObject.new serialized, serializer
+
+        assert_equal serialized, lazy.serialized_object
+        assert_equal serializer, lazy.serializer
+        assert_equal TestEvent, lazy.type
+
+        refute lazy.deserialized?
+
+        deserialized_a = lazy.deserialized
+        deserialized_b = lazy.deserialized
+
+        assert deserialized_a === deserialized_b
+        assert deserialized_a == event
+        assert deserialized_b == event
+
+        assert lazy.deserialized?
+      end
+    end
+  end
+end

data/test/serialization/message/metadata_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+    class SerializedMetadataTest < Test::Unit::TestCase
+      def test_initialize
+        content = 'test-metadata'
+        content_type = String
+
+        metadata = SerializedMetadata.new content, content_type
+
+        assert_equal content, metadata.content
+        assert_equal content_type, metadata.content_type
+        assert_equal Hash.to_s, metadata.type.name
+        assert_equal nil, metadata.type.revision
+      end
+    end
+  end
+end

data/test/serialization/message/serialization_aware_message_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+    class SerializationAwareDomainEventMessageTest < Test::Unit::TestCase
+      def test_delegation
+        message = Domain::DomainEventMessage.build do |builder|
+          builder.payload = Object.new
+          builder.aggregate_id = 123
+          builder.sequence_number = 0
+        end
+
+        aware = SerializationAwareDomainEventMessage.new message
+
+        # EventMessage
+        assert_same message.id, aware.id
+        assert_same message.metadata, aware.metadata
+        assert_same message.payload, aware.payload
+        assert_same message.timestamp, aware.timestamp
+
+        # DomainEventMessage
+        assert_same message.aggregate_id, aware.aggregate_id
+        assert_same message.sequence_number, aware.sequence_number
+      end
+
+      def test_caching
+        message = Domain::DomainEventMessage.build do |builder|
+          builder.payload = Object.new
+          builder.aggregate_id = 123
+          builder.sequence_number = 0
+        end
+
+        aware = SerializationAwareDomainEventMessage.new message
+
+        serializer_a = MarshalSerializer.new
+        serializer_b = MarshalSerializer.new
+
+        [:serialize_metadata, :serialize_payload].each do |method|
+          serialized_a = aware.send method, serializer_a, String
+          serialized_b = aware.send method, serializer_a, String
+          serialized_c = aware.send method, serializer_b, String
+
+          assert_same serialized_a, serialized_b
+          refute_same serialized_a, serialized_c
+        end
+      end
+
+      def test_decorate
+        message = Domain::DomainEventMessage.build
+
+        aware = SerializationAwareDomainEventMessage.decorate message
+        new_aware = SerializationAwareDomainEventMessage.decorate aware
+
+        assert_same aware, new_aware
+      end
+
+      def test_and_metadata
+        message = Domain::DomainEventMessage.build do |builder|
+          builder.metadata = { foo: 0 }
+        end
+
+        aware = SerializationAwareDomainEventMessage.new message
+        new_aware = aware.and_metadata Hash.new
+
+        assert_same new_aware, aware
+
+        new_aware = aware.and_metadata bar: 1
+
+        assert new_aware.is_a? SerializationAwareDomainEventMessage
+      end
+
+      def test_with_metadata
+        message = Domain::DomainEventMessage.build do |builder|
+          builder.metadata = { foo: 0 }
+        end
+
+        aware = SerializationAwareDomainEventMessage.new message
+        new_aware = aware.with_metadata foo: 0
+
+        assert_same new_aware, aware
+
+        new_aware = aware.with_metadata bar: 1
+
+        assert new_aware.is_a? SerializationAwareDomainEventMessage
+      end
+    end
+  end
+end

data/test/serialization/message/serialized_message_builder_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+
+    class SerializedDomainEventMessageBuilderTest < Test::Unit::TestCase
+      def test_from_data
+        builder = SerializedDomainEventMessageBuilder.new
+
+        serializer = MarshalSerializer.new
+
+        data = StubSerializedDomainEventData.new
+        data.id = 0
+        data.metadata = SerializedObject.new(nil, nil, SerializedType.new(Object.to_s, nil))
+        data.payload = SerializedObject.new(nil, nil, SerializedType.new(Object.to_s, nil))
+        data.aggregate_id = 1
+        data.sequence_number = 2
+
+        builder.from_data data, serializer
+
+        built = builder.build
+
+        assert_equal data.id, built.id
+
+        assert_equal data.metadata, built.serialized_metadata.serialized_object
+        assert_equal serializer, built.serialized_metadata.serializer
+        assert_equal data.payload, built.serialized_payload.serialized_object
+        assert_equal serializer, built.serialized_payload.serializer
+
+        assert_equal data.timestamp, built.timestamp
+        assert_equal data.aggregate_id, built.aggregate_id
+        assert_equal data.sequence_number, built.sequence_number
+      end
+    end
+
+    class StubSerializedDomainEventData < SerializedDomainEventData
+      attr_accessor :id, :metadata, :payload, :timestamp, :aggregate_id, :sequence_number
+    end
+
+  end
+end

data/test/serialization/message/serialized_message_test.rb

@@ -0,0 +1,140 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+
+    class SerializedMessageTest < Test::Unit::TestCase
+      def test_build
+        message = SerializedMessage.build do |builder|
+          assert builder.is_a? SerializedMessageBuilder
+        end
+        assert message.is_a? SerializedMessage
+      end
+    end
+
+    class SerializedEventMessageTest < Test::Unit::TestCase
+      def test_build
+        message = SerializedEventMessage.build do |builder|
+          assert builder.is_a? SerializedEventMessageBuilder
+        end
+        assert message.is_a? SerializedEventMessage
+      end
+    end
+
+    class SerializedDomainEventMessageTest < Test::Unit::TestCase
+      def setup
+        @serializer_a = MarshalSerializer.new
+        @serializer_b = MarshalSerializer.new
+      end
+
+      def test_serialization
+        metadata = { foo: 0 }
+        payload = { bar: 1 }
+
+        metadata_serialized = @serializer_a.serialize metadata, String
+        payload_serialized = @serializer_a.serialize payload, String
+
+        metadata_lazy = LazyObject.new metadata_serialized, @serializer_a
+        payload_lazy = LazyObject.new payload_serialized, @serializer_a
+
+        message = SerializedDomainEventMessage.build do |builder|
+          builder.metadata = metadata_lazy
+          builder.payload = payload_lazy
+        end
+
+        refute message.serialized_metadata.deserialized?
+        assert_equal metadata, message.metadata
+
+        assert_equal Hash, message.payload_type
+        refute message.serialized_payload.deserialized?
+
+        assert_equal payload, message.payload
+        assert message.serialized_payload.deserialized?
+
+        metadata_serialized_a = message.serialize_metadata @serializer_a, String
+        assert_same metadata_serialized, metadata_serialized_a
+        payload_serialized_a = message.serialize_payload @serializer_a, String
+        assert_same payload_serialized, payload_serialized_a
+
+        metadata_serialized_b = message.serialize_metadata @serializer_b, String
+        assert_equal metadata_serialized, metadata_serialized_b
+        payload_serialized_b = message.serialize_payload @serializer_b, String
+        assert_equal payload_serialized, payload_serialized_b
+      end
+
+      def test_and_metadata
+        metadata = { foo: 0 }
+        payload = { bar: 1 }
+
+        metadata_serialized = @serializer_a.serialize metadata, String
+        metadata_lazy = LazyObject.new metadata_serialized, @serializer_a
+        payload_serialized = @serializer_a.serialize metadata, String
+        payload_lazy = LazyObject.new payload_serialized, @serializer_a
+
+        message = SerializedDomainEventMessage.build do |builder|
+          builder.id = 1
+          builder.metadata = metadata_lazy
+          builder.payload = payload_lazy
+          builder.timestamp = Time.now
+          builder.aggregate_id = 2
+          builder.sequence_number = 3
+        end
+
+        new_message = message.and_metadata Hash.new
+        assert_same message, new_message
+
+        new_message = message.and_metadata baz: 3
+
+        merged = {
+          foo: 0,
+          baz: 3
+        }
+
+        assert_equal merged, new_message.metadata
+        assert_message_content_equal message, new_message
+      end
+
+      def test_with_metadata
+        metadata = { foo: 0 }
+        payload = { bar: 1 }
+
+        metadata_serialized = @serializer_a.serialize metadata, String
+        metadata_lazy = LazyObject.new metadata_serialized, @serializer_a
+        payload_serialized = @serializer_a.serialize metadata, String
+        payload_lazy = LazyObject.new payload_serialized, @serializer_a
+
+        message = SerializedDomainEventMessage.build do |builder|
+          builder.id = 1
+          builder.metadata = metadata_lazy
+          builder.payload = payload_lazy
+          builder.timestamp = Time.now
+          builder.aggregate_id = 2
+          builder.sequence_number = 3
+        end
+
+        new_message = message.with_metadata foo: 0
+        assert_same message, new_message
+
+        new_message = message.with_metadata baz: 3
+
+        replaced = {
+          baz: 3
+        }
+
+        assert_equal replaced, new_message.metadata
+        assert_message_content_equal message, new_message
+      end
+
+    private
+
+      def assert_message_content_equal(expected, actual)
+        assert_equal expected.id, actual.id
+        assert_equal expected.serialized_payload, actual.serialized_payload
+        assert_equal expected.timestamp, actual.timestamp
+        assert_equal expected.aggregate_id, actual.aggregate_id
+        assert_equal expected.sequence_number, actual.sequence_number
+      end
+    end
+
+  end
+end