synapse-core 0.1.2

data/test/event_sourcing/repository_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+require 'domain/fixtures'
+
+module Synapse
+  module EventSourcing
+    class EventSourcingRepositoryTest < Test::Unit::TestCase
+      def setup
+        @unit_provider = UnitOfWork::UnitOfWorkProvider.new
+        @unit = UnitOfWork::UnitOfWork.new @unit_provider
+        @unit.start
+        @factory = GenericAggregateFactory.new StubAggregate
+        @event_store = Object.new
+        @lock_manager = Repository::NullLockManager.new
+
+        @repository = EventSourcingRepository.new @factory, @event_store, @lock_manager
+        @repository.event_bus = EventBus::SimpleEventBus.new
+        @repository.unit_provider = @unit_provider
+      end
+
+      def test_add_compatibility
+        aggregate = Domain::Person.new 123, 'Polandball'
+
+        assert_raise ArgumentError do
+          @repository.add aggregate # Polandball can't into repository :(
+        end
+      end
+
+      def test_load
+        event = create_event(123, 0, StubCreatedEvent.new(123))
+
+        mock(@event_store).read_events(@factory.type_identifier, 123) do
+          Domain::SimpleDomainEventStream.new event
+        end
+
+        aggregate = @repository.load 123
+      end
+
+      def test_load_incorrect_version
+        event = create_event(123, 1, StubCreatedEvent.new(123))
+
+        mock(@event_store).read_events(@factory.type_identifier, 123) do
+          Domain::SimpleDomainEventStream.new event
+        end
+
+        assert_raise Repository::ConflictingAggregateVersionError do
+          aggregate = @repository.load 123, 0
+        end
+      end
+
+      def test_load_not_found
+        mock(@event_store).read_events(@factory.type_identifier, 123) do
+          raise EventStore::StreamNotFoundError.new @factory.type_identifier, 123
+        end
+
+        assert_raise Repository::AggregateNotFoundError do
+          @repository.load 123
+        end
+      end
+
+      def test_load_deleted
+        event_a = create_event(123, 0, StubCreatedEvent.new(123))
+        event_b = create_event(123, 1, StubDeletedEvent.new)
+
+        mock(@event_store).read_events(@factory.type_identifier, 123) do
+          Domain::SimpleDomainEventStream.new event_a, event_b
+        end
+
+        assert_raise AggregateDeletedError do
+          aggregate = @repository.load 123
+        end
+      end
+
+      def test_conflict_resolution
+        @repository.conflict_resolver = ConflictResolver.new
+
+        event_a = create_event(123, 0, StubCreatedEvent.new(123))
+        event_b = create_event(123, 1, StubChangedEvent.new)
+
+        mock(@event_store).read_events(@factory.type_identifier, 123) do
+          Domain::SimpleDomainEventStream.new event_a, event_b
+        end
+
+        mock(@event_store).append_events(@factory.type_identifier, anything)
+
+        aggregate = @repository.load 123, 0
+        aggregate.change_something
+
+        @unit.commit
+      end
+
+    private
+
+      def create_event(aggregate_id, seq, payload)
+        Domain::DomainEventMessage.build do |m|
+          m.aggregate_id = aggregate_id
+          m.sequence_number = seq
+          m.payload = payload
+        end
+      end
+    end
+  end
+end

data/test/event_sourcing/snapshot/aggregate_taker_test.rb

@@ -0,0 +1,39 @@
+require 'test_helper'
+require 'event_sourcing/fixtures'
+
+module Synapse
+  module EventSourcing
+
+    class AggregateSnapshotTakerTest < Test::Unit::TestCase
+      def test_schedule_snapshot
+        event_store = Object.new
+        aggregate_factory = GenericAggregateFactory.new StubAggregate
+
+        type_identifier = aggregate_factory.type_identifier
+        id = 123
+
+        event = Domain::DomainEventMessage.build do |builder|
+          builder.payload = StubCreatedEvent.new id
+          builder.sequence_number = 0
+          builder.aggregate_id = id
+        end
+        stream = Domain::SimpleDomainEventStream.new event
+
+        mock(event_store).read_events(type_identifier, id) do
+          stream
+        end
+
+        mock(event_store).append_snapshot_event(type_identifier, anything) do |_, snapshot|
+          assert_equal StubAggregate, snapshot.payload_type
+          assert_equal 0, snapshot.sequence_number
+          assert_equal id, snapshot.aggregate_id
+        end
+
+        snapshot_taker = AggregateSnapshotTaker.new event_store
+        snapshot_taker.register_factory aggregate_factory
+        snapshot_taker.schedule_snapshot type_identifier, id
+      end
+    end
+
+  end
+end

data/test/event_sourcing/snapshot/deferred_taker_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+module Synapse
+  module EventSourcing
+
+    class DeferredSnapshotTakerTest < Test::Unit::TestCase
+      def test_schedule_snapshot
+        delegate = Object.new
+
+        mock(EventMachine).defer.yields
+        mock(delegate).schedule_snapshot 'test', 123
+
+        snapshot_taker = DeferredSnapshotTaker.new delegate
+        snapshot_taker.schedule_snapshot 'test', 123
+      end
+    end
+
+  end
+end

data/test/event_sourcing/snapshot/integration_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+require 'event_sourcing/fixtures'
+
+module Synapse
+  module EventSourcing
+
+    class SnapshotIntegrationTest < Test::Unit::TestCase
+      def test_integration
+        unit_provider = Object.new
+        unit = Object.new
+
+        mock(unit_provider).current do
+          unit
+        end
+
+        listener = nil
+
+        mock(unit).register_listener(is_a(SnapshotUnitOfWorkListener)) do |l|
+          listener = l
+        end
+
+        event_store = Object.new
+
+        aggregate_id = 123
+        type_identifier = Object.to_s
+
+        aggregate = Object.new
+        mock(aggregate).id.any_times do
+          aggregate_id
+        end
+
+        snapshot_taker = Object.new
+        snapshot_trigger = EventCountSnapshotTrigger.new snapshot_taker, unit_provider
+        snapshot_trigger.threshold = 5
+
+        read_stream = create_stream 3
+        append_stream = create_stream 3
+
+        decorated_read_stream = snapshot_trigger.decorate_for_read type_identifier, aggregate_id, read_stream
+        decorated_read_stream.to_a # Causes stream to iterate over all events
+
+        decorated_append_stream = snapshot_trigger.decorate_for_append type_identifier, aggregate, append_stream
+        decorated_append_stream.to_a # Ditto
+
+        # At this point, there is a snapshot unit of work listener added
+        # Let's "cleanup" the unit of work and check if the snapshot is triggered
+
+        mock(snapshot_taker).schedule_snapshot type_identifier, aggregate_id
+
+        listener.on_cleanup unit
+      end
+
+      def create_stream(size)
+        events = Array.new
+
+        size.times do
+          events.push Domain::DomainEventMessage.build
+        end
+
+        Domain::SimpleDomainEventStream.new events
+      end
+    end
+
+  end
+end

data/test/event_sourcing/storage_listener_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+module Synapse
+  module EventSourcing
+
+    class EventSourcedStorageListenerTest < Test::Unit::TestCase
+      def test_store
+        event_store = Object.new
+        lock_manager = Repository::NullLockManager.new
+        decorators = Array.new
+        type_identifier = StubAggregate.to_s.demodulize
+        aggregate = Object.new
+
+        decorator = Object.new
+        decorators.push decorator
+
+        original_stream = Domain::DomainEventStream.new
+        decorated_stream = Domain::DomainEventStream.new
+
+        mock(aggregate).version
+        mock(aggregate).uncommitted_events do
+          original_stream
+        end
+        mock(aggregate).mark_committed
+
+        mock(decorator).decorate_for_append(type_identifier, aggregate, original_stream) do
+          decorated_stream
+        end
+
+        mock(event_store).append_events(type_identifier, decorated_stream)
+
+        listener = EventSourcedStorageListener.new event_store, lock_manager, decorators, type_identifier
+        listener.store aggregate
+      end
+
+      def test_store_locking
+        event_store = Object.new
+        lock_manager = Repository::NullLockManager.new
+        decorators = Array.new
+        type_identifier = StubAggregate.to_s.demodulize
+        aggregate = StubAggregate.new 123
+
+        mock(aggregate).version do
+          123
+        end
+
+        mock(event_store).append_events(type_identifier, anything)
+
+        listener = EventSourcedStorageListener.new event_store, lock_manager, decorators, type_identifier
+        listener.store aggregate
+      end
+
+      def test_store_lock_failed
+        event_store = Object.new
+        lock_manager = Object.new
+        decorators = Array.new
+        type_identifier = StubAggregate.to_s.demodulize
+        aggregate = Object.new
+
+        mock(aggregate).version do
+          123
+        end
+
+        mock(lock_manager).validate_lock(aggregate) do
+          false
+        end
+
+        listener = EventSourcedStorageListener.new event_store, lock_manager, decorators, type_identifier
+
+        assert_raise Repository::ConflictingModificationError do
+          listener.store aggregate
+        end
+      end
+    end
+
+  end
+end

data/test/event_store/in_memory_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+module Synapse
+  module EventStore
+    class InMemoryEventStoreTest < Test::Unit::TestCase
+
+      def setup
+        @event_store = InMemoryEventStore.new
+      end
+
+      def test_empty_stream
+        assert_raise StreamNotFoundError do
+          @event_store.read_events 'Person', 123
+        end
+      end
+
+      def test_append_and_read
+        event_a = Domain::DomainEventMessage.build { |e| e.aggregate_id = 123 }
+        event_b = Domain::DomainEventMessage.build { |e| e.aggregate_id = 123 }
+        event_c = Domain::DomainEventMessage.build { |e| e.aggregate_id = 123 }
+
+        stream_a = Domain::SimpleDomainEventStream.new event_a, event_b
+        stream_b = Domain::SimpleDomainEventStream.new event_c
+
+        @event_store.append_events 'Person', stream_a
+        @event_store.append_events 'Person', stream_b
+
+        stream = @event_store.read_events 'Person', 123
+
+        assert_equal [event_a, event_b, event_c], stream.to_a
+      end
+
+      def test_clear
+        event = Domain::DomainEventMessage.build { |e| e.aggregate_id = 123 }
+        stream = Domain::SimpleDomainEventStream.new event
+
+        @event_store.append_events 'Person', stream
+        @event_store.clear
+
+        assert_raise StreamNotFoundError do
+          @event_store.read_events 'Person', 123
+        end
+      end
+
+    end
+  end
+end

data/test/process_manager/correlation_set_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+module Synapse
+  module ProcessManager
+    class CorrelationSetTest < Test::Unit::TestCase
+
+      def test_add
+        correlation = Correlation.new :order_id, '512d5467-d319-481e-ab5e-4d6f7445bcff'
+
+        set = CorrelationSet.new
+        set.add correlation
+        set.add correlation
+
+        assert set.include? correlation
+        assert_equal 1, set.count
+        assert_equal 1, set.additions.count
+
+        set.commit
+
+        set.delete correlation
+        set.add correlation
+
+        assert_equal 1, set.count
+        assert_equal 0, set.additions.count
+        assert_equal 0, set.deletions.count
+      end
+
+      def test_delete
+        correlation = Correlation.new :order_id, '512d5467-d319-481e-ab5e-4d6f7445bcff'
+
+        set = CorrelationSet.new
+        set.add correlation
+        set.delete correlation
+
+        assert_equal 0, set.count
+        assert_equal 0, set.additions.count
+        assert_equal 0, set.deletions.count
+
+        set.add correlation
+        set.commit
+
+        set.delete correlation
+        assert_equal 0, set.count
+        assert_equal 1, set.deletions.count
+      end
+
+    end
+  end
+end

data/test/process_manager/correlation_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+module Synapse
+  module ProcessManager
+    class CorrelationTest < Test::Unit::TestCase
+      def test_intiialize
+        correlation = Correlation.new :foo, 'bar'
+
+        assert_equal :foo, correlation.key
+        assert_equal 'bar', correlation.value
+      end
+
+      def test_object_equality
+        correlation_a = Correlation.new :foo, 'bar'
+        correlation_b = Correlation.new :foo, 'bar'
+        correlation_c = Correlation.new :foo, 'baz'
+
+        assert_equal correlation_a, correlation_b
+        assert_equal correlation_b, correlation_b
+        refute_equal correlation_a, correlation_c
+      end
+    end
+  end
+end

data/test/process_manager/process_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+module Synapse
+  module ProcessManager
+
+    class ProcessTest < Test::Unit::TestCase
+      def test_initialize
+        process = StubProcess.new
+        correlation = Correlation.new :process_id, process.id
+
+        # If no identifier was given, one should be generated
+        refute process.id.nil?
+        assert process.correlations.include? correlation
+        assert process.active?
+      end
+
+      def test_dissociate_from
+        process = StubProcess.new
+
+        key = :order_id
+        value = '512d5467'
+
+        process.cause_correlate key, value
+        assert process.correlations.include? Correlation.new(key, value)
+
+        process.cause_dissociate key, value
+        refute process.correlations.include? Correlation.new(key, value)
+      end
+
+      def test_finish
+        process = StubProcess.new
+        process.cause_finish
+
+        refute process.active?
+      end
+    end
+
+    class StubProcess < Process
+      def cause_finish
+        finish
+      end
+
+      def cause_correlate(key, value)
+        correlate_with key, value
+      end
+      def cause_dissociate(key, value)
+        dissociate_from key, value
+      end
+    end
+
+  end
+end