public static void Init()
{
var bus = new Bus();
var cashier = new Cashier(bus);
var barista = new Barista(Guid.NewGuid(), bus);
var repository = new SagaRepository<OrderFufillment>(bus);
bus.RouteToSaga(repository, (DrinkOrdered e) => e.OrderId);
bus.RouteToSaga(repository, (DrinkPrepared e) => e.OrderId);
bus.RouteToSaga(repository, (PaymentReceived e) => e.OrderId);
bus.Register<OrderDrink>(c => cashier.Order(c.OrderId, c.Drink));
bus.RegisterOnThreadPool<Pay>(c => cashier.Pay(c.OrderId, PaymentMethod.CreditCard, c.Amount));
bus.RegisterOnThreadPool<PrepareDrink>(c => barista.PrepareDrink(c.OrderId, c.Drink));
bus.Register<NotifyCustomer>(c =>
{
Console.WriteLine("{0} is ready", c.OrderId);
ThreadPool.QueueUserWorkItem(_ => bus.Send(new Pay
{
OrderId =
c.OrderId,
Amount = 12m
}));
});
ServiceLocator.RegisterDispatcher<Command>(bus.Send);
WindowsCommunicationFoundation.RegisterServiceLayer<Sales>();
}
public async Task GivenAMongoDbSagaRepository_WhenSendingAndInstanceNotReturnedFromPolicy()
{
_correlationId = Guid.NewGuid();
_cancellationToken = new CancellationToken();
_context = new Mock <ConsumeContext <InitiateSimpleSaga> >();
_context.Setup(x => x.CorrelationId).Returns(_correlationId);
_context.Setup(m => m.CancellationToken).Returns(_cancellationToken);
_nullSimpleSaga = null;
_policy = new Mock <ISagaPolicy <SimpleSaga, InitiateSimpleSaga> >();
_policy.Setup(x => x.PreInsertInstance(_context.Object, out _nullSimpleSaga)).Returns(false);
_nextPipe = new Mock <IPipe <SagaConsumeContext <SimpleSaga, InitiateSimpleSaga> > >();
_simpleSaga = new SimpleSaga {
CorrelationId = _correlationId
};
_sagaConsumeContext = new Mock <SagaConsumeContext <SimpleSaga, InitiateSimpleSaga> >();
_sagaConsumeContext.Setup(x => x.CorrelationId).Returns(_correlationId);
_sagaConsumeContextFactory = new Mock <IMongoDbSagaConsumeContextFactory>();
_sagaConsumeContextFactory.Setup(m => m.Create(It.IsAny <IMongoCollection <SimpleSaga> >(), _context.Object, It.Is <SimpleSaga>(x => x.CorrelationId == _correlationId), true)).Returns(_sagaConsumeContext.Object);
await SagaRepository.InsertSaga(_simpleSaga);
var repository = new MongoDbSagaRepository <SimpleSaga>(SagaRepository.Instance, _sagaConsumeContextFactory.Object);
await repository.Send(_context.Object, _policy.Object, _nextPipe.Object);
}
public NHibernateSagaRepository(ISessionFactory sessionFactory)
{
var consumeContextFactory = new NHibernateSagaConsumeContextFactory <TSaga>();
var repositoryContextFactory = new NHibernateSagaRepositoryContextFactory <TSaga>(sessionFactory, consumeContextFactory);
_repository = new SagaRepository <TSaga>(repositoryContextFactory);
}
public MartenSagaRepository(IDocumentStore documentStore)
{
var consumeContextFactory = new MartenSagaConsumeContextFactory <TSaga>();
ISagaRepositoryContextFactory <TSaga> repositoryContextFactory = new MartenSagaRepositoryContextFactory <TSaga>(documentStore, consumeContextFactory);
_repository = new SagaRepository <TSaga>(repositoryContextFactory);
}
public DapperSagaRepository(string connectionString, IsolationLevel isolationLevel = IsolationLevel.Serializable)
{
var consumeContextFactory = new DapperSagaConsumeContextFactory <TSaga>();
var options = new DapperOptions <TSaga>(connectionString, isolationLevel);
var repositoryContextFactory = new DapperSagaRepositoryContextFactory <TSaga>(options, consumeContextFactory);
_repository = new SagaRepository <TSaga>(repositoryContextFactory);
}
public async Task GivenAMongoDbSagaConsumeContext_WhenSettingComplete()
{
_saga = new SimpleSaga {
CorrelationId = Guid.NewGuid()
};
await SagaRepository.InsertSaga(_saga);
_mongoDbSagaConsumeContext = new MongoDbSagaConsumeContext <SimpleSaga, InitiateSimpleSaga>(SagaRepository.Instance.GetCollection <SimpleSaga>("sagas"), Mock.Of <ConsumeContext <InitiateSimpleSaga> >(), _saga);
await _mongoDbSagaConsumeContext.SetCompleted();
}
public async Task GivenAMongoDbQuerySagaRepository_WhenFindingSaga()
{
_correlationId = Guid.NewGuid();
await SagaRepository.InsertSaga(new SimpleSaga()
{
CorrelationId = _correlationId
});
var repository = new MongoDbQuerySagaRepository <SimpleSaga>(SagaRepository.Instance);
var sagaQuery = new Mock <ISagaQuery <SimpleSaga> >();
sagaQuery.Setup(m => m.FilterExpression).Returns(x => x.CorrelationId == _correlationId);
_result = await repository.Find(sagaQuery.Object);
}
public SagaRepositoryTests()
{
unitOfWork = Substitute.For <IUnitOfWork>();
unitOfWork.When(x => x.AddInnerTransaction(Arg.Any <ITransaction>())).Do(ci => uowInnerTransaction = ci.ArgAt <ITransaction>(0));
commandBus = Substitute.For <ICommandBus>();
sagaMetadataRepository = Substitute.For <ISagaMetadataRepository>();
entityTypeManager = Substitute.For <IEntityTypeManager>();
repository = Substitute.ForPartsOf <FakeRepository>();
entityTypeManager = Substitute.For <IEntityTypeManager>();
entityTypeManager.GetClassInfoByClassId(saga1ClassId)
.Returns(new DomainClassInfo(saga1ClassId, null, typeof(Saga1)));
entityTypeManager.GetClassInfoByClrType(typeof(Saga1))
.Returns(new DomainClassInfo(saga1ClassId, null, typeof(Saga1)));
sut = new SagaRepository(commandBus, repository, sagaMetadataRepository, entityTypeManager, unitOfWork);
}
public DocumentDbSagaRepository(IDocumentClient client, string databaseName, string collectionName,
JsonSerializerSettings serializerSettings = null)
{
if (string.IsNullOrWhiteSpace(collectionName))
{
throw new ArgumentNullException(nameof(collectionName));
}
if (collectionName.Length > 120)
{
throw new ArgumentException("Collection names must be no longer than 120 characters", nameof(collectionName));
}
var databaseContext = new DocumentDbDatabaseContext <TSaga>(client, databaseName, collectionName ?? DefaultCollectionName, serializerSettings);
var consumeContextFactory = new DocumentDbSagaConsumeContextFactory <TSaga>();
var repositoryFactory = new DocumentDbSagaRepositoryContextFactory <TSaga>(databaseContext, consumeContextFactory);
_repository = new SagaRepository <TSaga>(repositoryFactory);
}
public async Task GivenAMongoDbSagaRepository_WhenSendingQuery()
{
_correlationId = Guid.NewGuid();
var saga = new SimpleSaga {
CorrelationId = _correlationId
};
await SagaRepository.InsertSaga(saga);
_sagaQueryConsumeContext = new Mock <SagaQueryConsumeContext <SimpleSaga, InitiateSimpleSaga> >();
_sagaQueryConsumeContext.Setup(x => x.Query.FilterExpression).Returns(x => x.CorrelationId == _correlationId);
_sagaPolicy = new Mock <ISagaPolicy <SimpleSaga, InitiateSimpleSaga> >();
_nextPipe = new Mock <IPipe <SagaConsumeContext <SimpleSaga, InitiateSimpleSaga> > >();
_sagaConsumeContext = new Mock <SagaConsumeContext <SimpleSaga, InitiateSimpleSaga> >();
_sagaConsumeContext.Setup(x => x.CorrelationId).Returns(_correlationId);
_sagaConsumeContextFactory = new Mock <IMongoDbSagaConsumeContextFactory>();
_sagaConsumeContextFactory.Setup(m => m.Create(It.IsAny <IMongoCollection <SimpleSaga> >(), _sagaQueryConsumeContext.Object, It.Is <SimpleSaga>(x => x.CorrelationId == _correlationId), true)).Returns(_sagaConsumeContext.Object);
var repository = new MongoDbSagaRepository <SimpleSaga>(SagaRepository.Instance, _sagaConsumeContextFactory.Object);
await repository.SendQuery(_sagaQueryConsumeContext.Object, _sagaPolicy.Object, _nextPipe.Object);
}
private static void Main(string[] args)
{
var bus = new Bus();
var cashier = new Cashier(bus);
var barista = new Barista(Guid.NewGuid(), bus);
var repository = new SagaRepository<OrderFufillment>(bus);
bus.RouteToSaga(repository, (DrinkOrdered e) => e.OrderId);
bus.RouteToSaga(repository, (DrinkPrepared e) => e.OrderId);
bus.RouteToSaga(repository, (PaymentReceived e) => e.OrderId);
bus.Register<OrderDrink>(c => cashier.Order(c.OrderId, c.Drink));
bus.RegisterOnThreadPool<Pay>(c => cashier.Pay(c.OrderId, PaymentMethod.CreditCard, c.Amount));
bus.RegisterOnThreadPool<PrepareDrink>(c => barista.PrepareDrink(c.OrderId, c.Drink));
bus.Register<NotifyCustomer>(c =>
{
Console.WriteLine("{0} is ready", c.OrderId);
ThreadPool.QueueUserWorkItem(_ => bus.Send(new Pay
{
OrderId =
c.OrderId,
Amount = 12m
}));
});
Guid orderId = Guid.NewGuid();
bus.Send(new OrderDrink {Drink = Drinks.Cappucino, OrderId = orderId});
bus.Send(new Pay
{
OrderId = orderId,
Amount = 10m
});
Console.ReadLine();
}
public Handler(SagaRepository repository)
{
_sagaService = repository;
}
public Handler(SagaRepository repository)
{
_repository = repository;
}
public Handler(SagaRepository sagaRepository, ChapterRepository chapterRepository)
{
_sagaRepository = sagaRepository;
_chapterRepository = chapterRepository;
}
public async Task Kill()
{
await SagaRepository.DeleteSaga(_saga.CorrelationId);
}
protected override void Establish_context()
{
base.Establish_context();
this.SagaRepository = new SagaRepository <FakeSaga>(this.SagaStore);
}
public async Task ThenSagaInsertedIntoMongo()
{
var saga = await SagaRepository.GetSaga(_saga.CorrelationId);
Assert.That(saga, Is.Not.Null);
}
public async Task ThenSagaDoesNotExistInRepository()
{
var saga = await SagaRepository.GetSaga(_saga.CorrelationId);
Assert.That(saga, Is.Null);
}
protected override void Because_of()
{
base.Because_of();
filteredList = SagaRepository.Where(new SagaFilter <FakeSaga>(s => s.Property == FilteredPropertyValue), s => s.Property);
}
public async Task ThenVersionIncremeted()
{
var saga = await SagaRepository.GetSaga(_correlationId);
Assert.That(saga.Version, Is.EqualTo(1));
}
public void ThenSagaInstanceStored()
{
Assert.That(SagaRepository.GetSaga(_correlationId), Is.Not.Null);
}
