synapse-core 0.1.2

data/test/serialization/message/serializer_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+    class MessageSerializerTest < Test::Unit::TestCase
+      def test_serialize
+        delegate = Object.new
+        serializer = MessageSerializer.new delegate
+
+        metadata = Hash.new
+        payload = Object.new
+
+        m = MessageBuilder.build do |b|
+          b.metadata = metadata
+          b.payload = payload
+        end
+
+        serialized_metadata = Object.new
+        serialized_payload = Object.new
+
+        mock(delegate).serialize(metadata, String) do
+          serialized_metadata
+        end
+        mock(delegate).serialize(payload, String) do
+          serialized_payload
+        end
+
+        assert_equal serialized_metadata, serializer.serialize_metadata(m, String)
+        assert_equal serialized_payload, serializer.serialize_payload(m, String)
+      end
+
+      def test_serialization_aware
+        delegate = Object.new
+        serializer = MessageSerializer.new delegate
+
+        stub_class = Class.new do
+          include SerializationAware
+        end
+
+        stub = stub_class.new
+
+        mock(stub).serialize_metadata(delegate, String)
+        mock(stub).serialize_payload(delegate, String)
+
+        serializer.serialize_metadata(stub, String)
+        serializer.serialize_payload(stub, String)
+      end
+    end
+  end
+end

data/test/serialization/revision_resolver_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+    class FixedRevisionResolverTest < Test::Unit::TestCase
+      def test_revision_of
+        resolver = FixedRevisionResolver.new 1
+        assert_equal '1', resolver.revision_of(Array)
+      end
+    end
+  end
+end

data/test/serialization/serialized_object_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+    class SerializedObjectTest < Test::Unit::TestCase
+
+      def test_attributes
+        content = 'some content'
+        type = SerializedType.new 'SomeClass', '1'
+
+        object = SerializedObject.new content, content.class, type
+
+        assert_equal content, object.content
+        assert_equal content.class, object.content_type
+        assert_equal type, object.type
+      end
+
+      def test_object_equality
+        type_a = SerializedType.new 'SomeClass', '1'
+        type_b = SerializedType.new 'SomeClass', '2'
+
+        a = SerializedObject.new 'content', String, type_a
+        b = SerializedObject.new 'content', String, type_a
+        c = SerializedObject.new 'content', String, type_b
+        d = SerializedObject.new 'content_derp', String, type_a
+
+        assert_equal a, b
+        refute_equal a, c
+        refute_equal a, d
+
+        assert_equal a.hash, b.hash
+      end
+
+    end
+  end
+end

data/test/serialization/serialized_type_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+    class SerializedTypeTest < Test::Unit::TestCase
+
+      def test_attributes
+        type = SerializedType.new 'SomeClass', '1'
+
+        assert_equal 'SomeClass', type.name
+        assert_equal '1', type.revision
+      end
+
+      def test_object_equality
+        a = SerializedType.new 'SomeClass', '1'
+        b = SerializedType.new 'SomeClass', '1'
+        c = SerializedType.new 'SomeClass', '2'
+
+        assert_equal a, b
+        refute_equal a, c
+        assert_equal a.hash, b.hash
+        refute_equal a.hash, c.hash
+      end
+
+    end
+  end
+end

data/test/serialization/serializer/marshal_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+require 'serialization/fixtures'
+
+module Synapse
+  module Serialization
+
+    class MarshalSerializerTest < Test::Unit::TestCase
+
+      def test_serialize_deserialize
+        serializer = MarshalSerializer.new
+        event = TestEvent.new 'derp', 'herp'
+
+        serialized_obj = serializer.serialize event, String
+        deserialized = serializer.deserialize serialized_obj
+
+        assert_equal event, deserialized
+      end
+
+    end
+
+  end
+end

data/test/serialization/serializer/oj_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+require 'serialization/fixtures'
+
+module Synapse
+  module Serialization
+
+    class OjSerializerTest < Test::Unit::TestCase
+      def setup
+        skip 'Oj not supported on JRuby' if defined? JRUBY_VERSION
+      end
+
+      def test_serialize_deserialize
+        serializer = OjSerializer.new
+        event = TestEvent.new 'derp', 'herp'
+
+        serialized_obj = serializer.serialize event, String
+        deserialized = serializer.deserialize serialized_obj
+
+        assert_equal event, deserialized
+      end
+    end
+
+  end
+end

data/test/serialization/serializer/ox_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+require 'serialization/fixtures'
+
+module Synapse
+  module Serialization
+
+    class OxSerializerTest < Test::Unit::TestCase
+      def setup
+        skip 'Ox not supported on JRuby' if defined? JRUBY_VERSION
+
+        @serializer = OxSerializer.new
+      end
+
+      def test_serialize_and_deserialize
+        event = TestEvent.new 'derp', 'herp'
+
+        serialized_obj = @serializer.serialize event, String
+        deserialized = @serializer.deserialize serialized_obj
+
+        assert_equal event, deserialized
+      end
+
+      def test_type_converison
+        type = SerializedType.new 'String', nil
+
+        assert_equal String, @serializer.class_for(type)
+        assert_equal type, @serializer.type_for(String)
+
+        assert_raise UnknownSerializedTypeError do
+          @serializer.class_for(SerializedType.new('NonExistentClass', nil))
+        end
+      end
+    end
+
+  end
+end

data/test/serialization/serializer_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+module Synapse
+  module Serialization
+
+    class SerializerTest < Test::Unit::TestCase
+      def test_revision
+        revision = '123'
+
+        serializer = Serializer.new
+        serializer.revision_resolver = FixedRevisionResolver.new revision
+
+        type = serializer.type_for Object
+
+        assert_equal revision, type.revision
+      end
+    end
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+if ENV['TRAVIS']
+  require 'coveralls'
+  Coveralls.wear!
+else
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/test/'
+  end
+end
+
+require 'pp'
+require 'test/unit'
+require 'rr'
+require 'timecop'
+require 'synapse'
+
+class Test::Unit::TestCase
+  include RR::Adapters::TestUnit
+end

data/test/uow/factory_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+module Synapse
+  module UnitOfWork
+    class UnitOfWorkFactoryTest < Test::Unit::TestCase
+      def test_create
+        provider = UnitOfWorkProvider.new
+        txm = Object.new
+        factory = UnitOfWorkFactory.new provider
+        factory.transaction_manager = txm
+
+        mock(txm).start {
+          Object.new
+        }
+
+        uow = factory.create
+
+        assert uow.started?
+        assert uow.transactional?
+      end
+    end
+  end
+end

data/test/uow/outer_commit_listener_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module Synapse
+  module UnitOfWork
+    class OuterCommitUnitOfWorkListenerTest < Test::Unit::TestCase
+      def setup
+        @provider = Object.new
+        @outer_unit = Object.new
+        @inner_unit = Object.new
+        @listener = OuterCommitUnitOfWorkListener.new @inner_unit, @provider
+      end
+
+      def test_after_commit
+        mock(@inner_unit).perform_inner_commit
+        @listener.after_commit @outer_unit
+      end
+
+      def test_on_rollback
+        cause = TestError.new
+
+        mock(@provider).push(@inner_unit)
+        mock(@inner_unit).perform_rollback(cause)
+        mock(@provider).clear(@inner_unit)
+
+        @listener.on_rollback @outer_unit, cause
+      end
+
+      def test_on_rollback_handles_exception
+        cause = TestError.new
+
+        mock(@provider).push(@inner_unit)
+        mock(@inner_unit).perform_rollback(cause) {
+          raise TestError
+        }
+        mock(@provider).clear(@inner_unit)
+
+        assert_raises TestError do
+          @listener.on_rollback @outer_unit, cause
+        end
+      end
+
+      def test_on_cleanup
+        mock(@inner_unit).perform_cleanup
+        @listener.on_cleanup @outer_unit
+      end
+    end
+
+    class TestError < StandardError; end
+  end
+end

data/test/uow/provider_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+module Synapse
+  module UnitOfWork
+    class UnitOfWorkProviderTest < Test::Unit::TestCase
+      def setup
+        @provider = UnitOfWorkProvider.new
+      end
+
+      def test_clear
+        uow = UnitOfWork.new @provider
+        uow.start
+
+        assert @provider.started?
+        @provider.clear uow
+        refute @provider.started?
+      end
+
+      def test_clear_raises_mismatch
+        outer = UnitOfWork.new @provider
+        inner = UnitOfWork.new @provider
+
+        outer.start
+        inner.start
+
+        assert_raises ArgumentError do
+          @provider.clear outer
+        end
+      end
+
+      def test_commit
+        uow = UnitOfWork.new @provider
+        uow.start
+
+        @provider.commit
+
+        refute @provider.started?
+        refute uow.started?
+      end
+
+      def test_current
+        uow = UnitOfWork.new @provider
+
+        assert_raises RuntimeError do
+          @provider.current
+        end
+
+        uow.start
+
+        assert_same uow, @provider.current
+      end
+
+      def test_threading
+        t1 = Thread.new {
+          uow = UnitOfWork.new @provider
+          uow.start
+
+          @provider.started?
+        }.join
+
+        t2 = Thread.new {
+          @provider.started?
+        }.join
+
+        assert t1.value
+        refute t2.value
+      end
+    end
+  end
+end

data/test/uow/uow_test.rb

@@ -0,0 +1,337 @@
+require 'test_helper'
+
+module Synapse
+  module UnitOfWork
+    class UnitOfWorkTest < Test::Unit::TestCase
+      def setup
+        @provider = UnitOfWorkProvider.new
+        @uow = UnitOfWork.new @provider
+      end
+
+      def teardown
+        if @provider.started?
+          raise 'Unit of work was not properly cleared from the provider'
+        end
+      end
+
+      def test_start_raises
+        @uow.start
+
+        assert_raises RuntimeError do
+          @uow.start
+        end
+
+        @uow.rollback
+      end
+
+      def test_commit_raises_if_not_started
+        assert_raises RuntimeError do
+          @uow.commit
+        end
+      end
+
+      def test_similar_aggregates
+        aggregate_a = TestAggregateA.new 1
+        aggregate_b = TestAggregateB.new 2
+        aggregate_c = TestAggregateB.new 3
+        aggregate_d = TestAggregateB.new 3
+
+        event_bus = Object.new
+        storage_listener = Object.new
+
+        assert_same aggregate_a, @uow.register_aggregate(aggregate_a, event_bus, storage_listener)
+        assert_same aggregate_b, @uow.register_aggregate(aggregate_b, event_bus, storage_listener)
+        assert_same aggregate_c, @uow.register_aggregate(aggregate_c, event_bus, storage_listener)
+        assert_same aggregate_c, @uow.register_aggregate(aggregate_d, event_bus, storage_listener)
+      end
+
+      def test_tx_bound_uow_lifecycle
+        listener = UnitOfWorkListener.new
+
+        tx = Object.new
+        txm = Object.new
+        mock(txm).start {
+          tx
+        }
+
+        mock(listener).on_start(@uow).ordered
+        mock(listener).on_prepare_commit(@uow, anything, anything).ordered
+        mock(listener).on_prepare_transaction_commit(@uow, tx).ordered
+        mock(txm).commit(tx).ordered
+        mock(listener).after_commit(@uow).ordered
+        mock(listener).on_cleanup(@uow).ordered
+
+        @uow.transaction_manager = txm
+        @uow.register_listener listener
+        @uow.start
+
+        @uow.commit
+      end
+
+      def test_tx_bound_uow_rollback_lifecycle
+        listener = UnitOfWorkListener.new
+
+        tx = Object.new
+        txm = Object.new
+        mock(txm).start {
+          tx
+        }
+
+        mock(listener).on_start(@uow).ordered
+        mock(txm).rollback(tx).ordered
+        mock(listener).on_rollback(@uow, nil).ordered
+        mock(listener).on_cleanup(@uow).ordered
+
+        @uow.transaction_manager = txm
+        @uow.register_listener listener
+        @uow.start
+
+        @uow.rollback
+      end
+
+      def test_uow_registers_listener_with_parent
+        outer_unit = Object.new
+        mock(outer_unit).register_listener(is_a(OuterCommitUnitOfWorkListener))
+        mock(outer_unit).rollback
+
+        @provider.push outer_unit
+
+        inner_unit = create_uow
+
+        inner_unit.rollback
+        outer_unit.rollback
+
+        @provider.clear outer_unit
+      end
+
+      def test_inner_rolled_back_with_outer
+        outer_unit = create_uow
+        inner_unit = create_uow
+
+        listener = UnitOfWorkListener.new
+        mock(listener).on_rollback(inner_unit, nil)
+
+        inner_unit.register_listener listener
+
+        inner_unit.commit
+        outer_unit.rollback
+      end
+
+      def test_inner_committed_with_outer
+        outer_unit = create_uow
+        inner_unit = create_uow
+
+        committed = false
+
+        listener = UnitOfWorkListener.new
+        mock(listener).after_commit(inner_unit) {
+          committed = true
+        }
+
+        inner_unit.register_listener listener
+        inner_unit.commit
+
+        refute committed, 'Inner unit was committed prematurely'
+
+        outer_unit.commit
+
+        assert committed, 'Inner unit should have been committed'
+      end
+
+      def test_unit_rollback_on_prepare_commit_error
+        cause = TestError.new
+        listener = UnitOfWorkListener.new
+
+        mock(listener).on_prepare_commit(@uow, anything, anything) {
+          raise cause
+        }
+        mock(listener).on_rollback(@uow, cause)
+        mock(listener).after_commit.never
+        mock(listener).on_cleanup(@uow)
+
+        @uow.register_listener listener
+        @uow.start
+
+        assert_raises TestError do
+          @uow.commit
+        end
+      end
+
+      def test_unit_rollback_on_store_aggregate_error
+        aggregate_root = Object.new
+        mock(aggregate_root).add_registration_listener
+        mock(aggregate_root).id
+
+        event_bus = Object.new
+        cause = TestError.new
+
+        storage_listener = Object.new
+        mock(storage_listener).store(aggregate_root) {
+          raise cause
+        }
+
+        listener = UnitOfWorkListener.new
+        mock(listener).on_prepare_commit(@uow, anything, anything)
+        mock(listener).on_rollback(@uow, cause)
+        mock(listener).after_commit.never
+        mock(listener).on_cleanup(@uow)
+
+        @uow.start
+        @uow.register_listener listener
+        @uow.register_aggregate aggregate_root, event_bus, storage_listener
+
+        assert_raises TestError do
+          @uow.commit
+        end
+      end
+
+      def test_unit_rollback_on_publish_error
+        cause = TestError.new
+        event = Object.new
+
+        event_bus = Object.new
+        mock(event_bus).publish([event]) {
+          raise cause
+        }
+
+        listener = UnitOfWorkListener.new
+        mock(listener).on_event_registered(@uow, event) {
+          event
+        }
+        mock(listener).after_commit.never
+
+        @uow.start
+        @uow.register_listener listener
+        @uow.publish_event event, event_bus
+
+        assert_raises TestError do
+          @uow.commit
+        end
+      end
+
+      def test_inner_cleanup_delayed_until_outer_cleanup_inner_commit
+        outer_listener = UnitOfWorkListener.new
+        inner_listener = UnitOfWorkListener.new
+
+        outer_unit = create_uow
+        inner_unit = create_uow
+
+        outer_unit.register_listener outer_listener
+        inner_unit.register_listener inner_listener
+
+        mock(inner_listener).after_commit(inner_unit).ordered
+        mock(outer_listener).after_commit(outer_unit).ordered
+        mock(inner_listener).on_cleanup(inner_unit).ordered
+        mock(outer_listener).on_cleanup(outer_unit).ordered
+
+        inner_unit.commit
+        outer_unit.commit
+      end
+
+      def test_inner_cleanup_delayed_until_outer_cleanup_inner_rollback
+        outer_listener = UnitOfWorkListener.new
+        inner_listener = UnitOfWorkListener.new
+
+        outer_unit = create_uow
+        inner_unit = create_uow
+
+        outer_unit.register_listener outer_listener
+        inner_unit.register_listener inner_listener
+
+        mock(inner_listener).on_rollback(inner_unit, nil).ordered
+        mock(outer_listener).after_commit(outer_unit).ordered
+        mock(inner_listener).on_cleanup(inner_unit).ordered
+        mock(outer_listener).on_cleanup(outer_unit).ordered
+
+        inner_unit.rollback
+        outer_unit.commit
+      end
+
+      def test_inner_cleanup_delayed_until_outer_cleanup_inner_commit_outer_rollback
+        outer_listener = UnitOfWorkListener.new
+        inner_listener = UnitOfWorkListener.new
+
+        outer_unit = create_uow
+        inner_unit = create_uow
+
+        outer_unit.register_listener outer_listener
+        inner_unit.register_listener inner_listener
+
+        mock(inner_listener).on_prepare_commit(inner_unit, anything, anything).ordered
+        mock(inner_listener).on_rollback(inner_unit, nil).ordered
+        mock(outer_listener).on_rollback(outer_unit, nil).ordered
+        mock(inner_listener).on_cleanup(inner_unit).ordered
+        mock(outer_listener).on_cleanup(outer_unit).ordered
+
+        inner_unit.commit
+        outer_unit.rollback
+      end
+
+      def test_set_txm_throws_if_started
+        @uow.start
+
+        assert_raises RuntimeError do
+          @uow.transaction_manager = Object.new
+        end
+
+        @uow.commit
+      end
+
+      def test_provider_not_changed_if_start_fails
+        txm = Object.new
+        mock(txm).start {
+          raise 'Something bad happened'
+        }
+
+        @uow.transaction_manager = txm
+
+        begin
+          @uow.start
+        rescue RuntimeError; end
+
+        refute @provider.started?
+      end
+
+      def test_events_continually_publish
+        @uow.start
+
+        event_bus = EventBus::SimpleEventBus.new
+
+        event_a = Domain::EventMessage.build
+        event_b = Domain::EventMessage.build
+
+        listener = Object.new
+        mock(listener).notify(event_a) {
+          @uow.publish_event event_b, event_bus
+        }
+        mock(listener).notify(event_b)
+
+        event_bus.subscribe listener
+
+        @uow.publish_event event_a, event_bus
+        @uow.commit
+      end
+
+      def create_uow
+        uow = UnitOfWork.new @provider
+        uow.start
+        uow
+      end
+    end
+
+    class TestError < StandardError; end
+
+    class TestAggregateA
+      include Domain::AggregateRoot
+      def initialize(id)
+        @id = id
+      end
+    end
+    class TestAggregateB
+      include Domain::AggregateRoot
+      def initialize(id)
+        @id = id
+      end
+    end
+  end
+end