public void Should_throw_if_different_object_with_tracked_guid_is_added()
 {
     var aggregate = new TestSnapshotAggregate();
     var aggregate2 = new TestSnapshotAggregate();
     aggregate2.SetId(aggregate.Id);
     _session.Add(aggregate);
     Assert.Throws<ConcurrencyException>(() => _session.Add(aggregate2));
 }
 public void Setup()
 {
     var eventStore = new TestEventStore();
     var snapshotStore = new NullSnapshotStore();
     var snapshotStrategy = new DefaultSnapshotStrategy();
     var repository = new SnapshotRepository(snapshotStore, snapshotStrategy, new Repository(eventStore), eventStore);
     var session = new Session(repository);
     _aggregate = session.Get<TestSnapshotAggregate>(Guid.NewGuid());
 }
 public When_getting_a_snapshot_aggregate_with_no_snapshot()
 {
     var eventStore = new TestEventStore();
     var snapshotStore = new NullSnapshotStore();
     var snapshotStrategy = new DefaultSnapshotStrategy();
     var repository = new SnapshotRepository(snapshotStore, snapshotStrategy, new Repository(eventStore), eventStore);
     var session = new Session(repository);
     _aggregate = session.Get<TestSnapshotAggregate>(Guid.NewGuid());
 }
 public void Setup()
 {
     var eventStore = new TestEventStore();
     var eventPublisher = new TestEventPublisher();
     var snapshotStore = new TestSnapshotStore();
     var snapshotStrategy = new DefaultSnapshotStrategy();
     var rep = new Repository<TestSnapshotAggregate>(eventStore, snapshotStore, eventPublisher, snapshotStrategy);
     _aggregate = rep.Get(Guid.NewGuid());
 }
        public When_getting_snapshotable_aggreate()
        {
            var eventStore = new TestInMemoryEventStore();
            _snapshotStore = new TestSnapshotStore();
            var snapshotStrategy = new DefaultSnapshotStrategy();
            var repository = new SnapshotRepository(_snapshotStore, snapshotStrategy, new Repository(eventStore), eventStore);
            var session = new Session(repository);

            _aggregate = session.Get<TestSnapshotAggregate>(Guid.NewGuid());
        }
        public When_getting_an_aggregate_with_snapshot()
        {
            var eventStore = new TestInMemoryEventStore();
            var eventPublisher = new TestEventPublisher();
            var snapshotStore = new TestSnapshotStore();
            var snapshotStrategy = new DefaultSnapshotStrategy();
            var snapshotRepository = new SnapshotRepository(snapshotStore, snapshotStrategy, new Repository(eventStore, eventPublisher), eventStore);
            var session = new Session(snapshotRepository);

            _aggregate = session.Get<TestSnapshotAggregate>(Guid.NewGuid());
        }
 public void Setup()
 {
     var eventStore = new TestEventStore();
     var eventPublisher = new TestEventPublisher();
     _snapshotStore = new TestSnapshotStore();
     var snapshotStrategy = new DefaultSnapshotStrategy();
     var rep = new Repository<TestSnapshotAggregate>(eventStore, _snapshotStore, eventPublisher, snapshotStrategy);
     var aggregate = new TestSnapshotAggregate();
     for (int i = 0; i < 30; i++)
     {
         aggregate.DoSomething();
     }
     rep.Save(aggregate, 0);
 }
 public void Setup()
 {
     var eventStore = new TestInMemoryEventStore();
     _snapshotStore = new TestSnapshotStore();
     var snapshotStrategy = new DefaultSnapshotStrategy();
     var repository = new SnapshotRepository(_snapshotStore, snapshotStrategy, new Repository(eventStore), eventStore);
     var session = new Session(repository);
     var aggregate = new TestSnapshotAggregate();
     for (var i = 0; i < 200; i++)
     {
         aggregate.DoSomething();
     }
     session.Add(aggregate);
     session.Commit();
 }
 public When_saving_a_snapshotable_aggregate()
 {
     var eventStore = new TestInMemoryEventStore();
     var eventPublisher = new TestEventPublisher();
     _snapshotStore = new TestSnapshotStore();
     var snapshotStrategy = new DefaultSnapshotStrategy();
     var repository = new SnapshotRepository(_snapshotStore, snapshotStrategy, new Repository(eventStore, eventPublisher), eventStore);
     var session = new Session(repository);
     var aggregate = new TestSnapshotAggregate();
     for (var i = 0; i < 30; i++)
     {
         aggregate.DoSomething();
     }
     session.Add(aggregate);
     session.Commit();
 }
        public When_saving_a_snapshotable_aggregate_for_each_change()
        {
            IEventStore eventStore = new TestInMemoryEventStore();
            _snapshotStore = new TestInMemorySnapshotStore();
            var snapshotStrategy = new DefaultSnapshotStrategy();
            var repository = new SnapshotRepository(_snapshotStore, snapshotStrategy, new Repository(eventStore), eventStore);
            _session = new Session(repository);
            _aggregate = new TestSnapshotAggregate();

            for (var i = 0; i < 150; i++)
            {
                _session.Add(_aggregate);
                _aggregate.DoSomething();
                _session.Commit();
            }
        }
        public void Setup()
        {
            IEventStore eventStore = new TestInMemoryEventStore();
            var eventPublisher = new TestEventPublisher();
            _snapshotStore = new TestInMemorySnapshotStore();
            var snapshotStrategy = new DefaultSnapshotStrategy();
            var repository = new SnapshotRepository(_snapshotStore, snapshotStrategy, new Repository(eventStore, eventPublisher), eventStore);
            _session = new Session(repository);
            var aggregate = new TestSnapshotAggregate();

            for (int i = 0; i < 20; i++)
            {
                _session.Add(aggregate);
                aggregate.DoSomething();
                _session.Commit();
            }
        }
        public When_saving_a_snapshotable_aggregate_for_each_change()
        {
            IEventStore eventStore = new TestInMemoryEventStore();

            _snapshotStore = new TestInMemorySnapshotStore();
            var snapshotStrategy = new DefaultSnapshotStrategy();
            var repository       = new SnapshotRepository(_snapshotStore, snapshotStrategy, new Repository(eventStore), eventStore);

            _session   = new Session(repository);
            _aggregate = new TestSnapshotAggregate();

            for (var i = 0; i < 150; i++)
            {
                _session.Add(_aggregate);
                _aggregate.DoSomething();
                _session.Commit();
            }
        }
        public void Setup()
        {
            var eventStore     = new TestInMemoryEventStore();
            var eventPublisher = new TestEventPublisher();

            _snapshotStore = new TestSnapshotStore();
            var snapshotStrategy = new DefaultSnapshotStrategy();
            var repository       = new SnapshotRepository(_snapshotStore, snapshotStrategy, new Repository(eventStore, eventPublisher), eventStore);
            var session          = new Session(repository);
            var aggregate        = new TestSnapshotAggregate();

            for (var i = 0; i < 30; i++)
            {
                aggregate.DoSomething();
            }
            session.Add(aggregate);
            session.Commit();
        }
Esempio n. 14
0
        public SaveSnapshotableAggregateForEachChange()
        {
            IEventStore eventStore = new TestInMemoryEventStore();

            _snapshotStore = new TestInMemorySnapshotStore();
            var snapshotStrategy = new DefaultSnapshotStrategy(_snapshotStore);
            var repository       = new SnapshotRepository(_snapshotStore, snapshotStrategy, new Repository(eventStore), eventStore);

            _session   = new Session(repository);
            _aggregate = new TestSnapshotAggregate();

            for (var i = 0; i < 150; i++)
            {
                _session.Add(_aggregate);
                _aggregate.DoSomething();
                _session.CommitAsync().Wait();
            }
        }
        public void Setup()
        {
            var eventStore     = new TestInMemoryEventStore();
            var eventPublisher = new TestEventPublisher();

            _snapshotStore = new TestSnapshotStore();
            var snapshotStrategy = new DefaultSnapshotStrategy <ISingleSignOnToken>();
            var aggregateFactory = new AggregateFactory(null);
            var repository       = new SnapshotRepository <ISingleSignOnToken>(_snapshotStore, snapshotStrategy, new Repository <ISingleSignOnToken>(aggregateFactory, eventStore, eventPublisher, new NullCorrelationIdHelper()), eventStore, aggregateFactory);
            var session          = new UnitOfWork <ISingleSignOnToken>(repository);
            var aggregate        = new TestSnapshotAggregate();

            for (int i = 0; i < 30; i++)
            {
                aggregate.DoSomething();
            }
            session.Add(aggregate);
            session.Commit();
        }
Esempio n. 16
0
        public void SnapshotShouldBeSuccessfullyAppliedToAggregate()
        {
            var persistentSnapshotStore = new InMemorySnapshotStore();
            var snapshotStore           = new SnapshotStore(persistentSnapshotStore);

            var          guid      = Guid.NewGuid();
            const string name      = "Test aggregate";
            var          aggregate = new TestSnapshotAggregate(guid, name);

            snapshotStore.SaveSnapshot(aggregate);
            var snapshot = snapshotStore.GetSnapshot(guid) as TestAggregateSnapshot;

            var newAggregate = new TestSnapshotAggregate(Guid.NewGuid(), String.Empty);

            newAggregate.SetSnapshot(snapshot);

            newAggregate.Id.Should().Be(guid);
            newAggregate.ReturnNameForTest().Should().Be(name);
        }
Esempio n. 17
0
        public void SnapshotProcessorShouldNotCreateSnapshotBeforeThresholdIsReached()
        {
            EventBus              eventBus;
            EventStore            eventStore;
            SnapshotStore         snapshotStore;
            SnapshotProcessor     snapshotProcessor;
            InMemorySnapshotStore memorySnapshotStore;
            var repository = EnvironmentMock.CreateEnvironment <TestSnapshotAggregate>(out eventBus, out eventStore,
                                                                                       out snapshotStore, out snapshotProcessor, out memorySnapshotStore, 3);

            var guid      = Guid.NewGuid();
            var aggregate = new TestSnapshotAggregate(guid, "Test Snapshot Aggregate v0");

            aggregate.ChangeName("Test Snapshot Aggregate v1");

            repository.Save(aggregate, -1);

            memorySnapshotStore.Find(guid).Should().BeEmpty();
        }
        public When_saving_a_snapshotable_aggregate()
        {
            var eventStore = new TestInMemoryEventStore();

            _snapshotStore = new TestSnapshotStore();
            var snapshotStrategy = new DefaultSnapshotStrategy();
            var repository       = new SnapshotRepository(_snapshotStore, snapshotStrategy, new Repository(eventStore), eventStore);
            var session          = new Session(repository);
            var aggregate        = new TestSnapshotAggregate();

            for (var i = 0; i < 200; i++)
            {
                aggregate.DoSomething();
            }
            Task.Run(async() =>
            {
                await session.Add(aggregate);
                await session.Commit();
            }).Wait();
        }
        public void Setup()
        {
            IEventStore <ISingleSignOnToken> eventStore = new TestInMemoryEventStore();
            var eventPublisher = new TestEventPublisher();

            _snapshotStore = new TestInMemorySnapshotStore();
            var snapshotStrategy = new DefaultSnapshotStrategy <ISingleSignOnToken>();
            var aggregateFactory = new AggregateFactory(new TestDependencyResolver());
            var repository       = new SnapshotRepository <ISingleSignOnToken>(_snapshotStore, snapshotStrategy, new Repository <ISingleSignOnToken>(aggregateFactory, eventStore, eventPublisher, new NullCorrelationIdHelper()), eventStore, aggregateFactory);

            _unitOfWork = new UnitOfWork <ISingleSignOnToken>(repository);
            _aggregate  = new TestSnapshotAggregate();

            for (var i = 0; i < 20; i++)
            {
                _unitOfWork.Add(_aggregate);
                _aggregate.DoSomething();
                _unitOfWork.Commit();
            }
        }
        public When_saving_a_snapshotable_aggregate_with_custom_interval()
        {
            IEventStore eventStore = new TestInMemoryEventStore();

            _snapshotStore = new TestInMemorySnapshotStore();
            var snapshotStrategy = new DefaultSnapshotStrategy(23);
            var repository       = new SnapshotRepository(_snapshotStore, snapshotStrategy, new Repository(eventStore), eventStore);

            _session   = new Session(repository);
            _aggregate = new TestSnapshotAggregate(Guid.NewGuid());

            Task.Run(async() =>
            {
                for (var i = 0; i < 50; i++)
                {
                    await _session.Add(_aggregate);
                    _aggregate.DoSomething();
                    await _session.Commit();
                }
            }).Wait();
        }
Esempio n. 21
0
        public WhenSavingASnapshotableAggregate()
        {
            var eventStore = new TestInMemoryEventStore();

            _snapshotStore = new TestSnapshotStore();
            var snapshotStrategy = new DefaultSnapshotStrategy(_snapshotStore);
            var repository       = new SnapshotRepository(_snapshotStore, snapshotStrategy, new Repository(eventStore),
                                                          eventStore);
            var eventStoreSettings = new TestEventStoreSettings {
                SessionLockEnabled = false
            };
            var session   = new Session(repository, eventStoreSettings, null);
            var aggregate = new TestSnapshotAggregate();

            for (var i = 0; i < 200; i++)
            {
                aggregate.DoSomething();
            }
            Task.Run(async() =>
            {
                session.Add(aggregate);
                await session.CommitAsync();
            }).Wait();
        }
 public void Should_not_throw_if_object_already_tracked()
 {
     var aggregate = new TestSnapshotAggregate();
     _session.Add(aggregate);
     _session.Add(aggregate);
 }