public static async Task <Guid?> ShouldContainSagaInState <TStateMachine, TInstance>(this ISagaRepository <TInstance> repository, Guid correlationId,
TStateMachine machine, Func <TStateMachine, State> stateSelector, TimeSpan timeout)
where TStateMachine : SagaStateMachine <TInstance>
where TInstance : class, SagaStateMachineInstance
{
var querySagaRepository = repository as IQuerySagaRepository <TInstance>;
if (querySagaRepository == null)
{
throw new ArgumentException("The repository must support querying", nameof(repository));
}
var state = stateSelector(machine);
DateTime giveUpAt = DateTime.Now + timeout;
var query = new SagaQuery <TInstance>(x => x.CorrelationId == correlationId && machine.GetState(x).Result.Equals(state));
while (DateTime.Now < giveUpAt)
{
Guid saga = (await querySagaRepository.Find(query).ConfigureAwait(false)).FirstOrDefault();
if (saga != Guid.Empty)
{
return(saga);
}
await Task.Delay(10).ConfigureAwait(false);
}
return(default);
bool ISagaQueryFactory <TSaga, TMessage> .TryCreateQuery(ConsumeContext <TMessage> context, out ISagaQuery <TSaga> query)
{
Expression <Func <TSaga, bool> > expression = new SagaFilterExpressionConverter <TSaga, TMessage>(context.Message)
.Convert(_filterExpression);
query = new SagaQuery <TSaga>(expression);
return(true);
}
bool ISagaQueryFactory <TInstance, TData> .TryCreateQuery(ConsumeContext <TData> context, out ISagaQuery <TInstance> query)
{
Expression <Func <TInstance, bool> > filter = new EventCorrelationExpressionConverter <TInstance, TData>(context)
.Convert(_correlationExpression);
query = new SagaQuery <TInstance>(filter);
return(true);
}
public void GivenAMongoDbQuerySagaRepository_WhenFindingSaga()
{
_correlationId = Guid.NewGuid();
SagaRepository.InsertSaga(new SimpleSaga {CorrelationId = _correlationId}).GetAwaiter().GetResult();
var repository = new MongoDbQuerySagaRepository<SimpleSaga>(SagaRepository.Instance);
ISagaQuery<SimpleSaga> query = new SagaQuery<SimpleSaga>(x => x.CorrelationId == _correlationId);
_result = repository.Find(query).GetAwaiter().GetResult();
}
public async Task GivenAMongoDbQuerySagaRepository_WhenFindingSaga()
{
_correlationId = Guid.NewGuid();
await SagaRepository.InsertSaga(new SimpleSaga { CorrelationId = _correlationId });
var repository = new MongoDbQuerySagaRepository <SimpleSaga>(SagaRepository.Instance);
ISagaQuery <SimpleSaga> query = new SagaQuery <SimpleSaga>(x => x.CorrelationId == _correlationId);
_result = await repository.Find(query);
}
bool ISagaQueryFactory <TInstance, TData> .TryCreateQuery(ConsumeContext <TData> context, out ISagaQuery <TInstance> query)
{
if (_selector.TryGetProperty(context, out var propertyValue))
{
Expression <Func <TInstance, bool> > filterExpression = CreateExpression(propertyValue);
query = new SagaQuery <TInstance>(filterExpression);
return(true);
}
query = default;
return(false);
}
public void GivenAMongoDbQuerySagaRepository_WhenFindingSaga()
{
_correlationId = Guid.NewGuid();
SagaRepository.InsertSaga(new SimpleSaga {
CorrelationId = _correlationId
}).GetAwaiter().GetResult();
var repository = new MongoDbQuerySagaRepository <SimpleSaga>(SagaRepository.Instance);
ISagaQuery <SimpleSaga> query = new SagaQuery <SimpleSaga>(x => x.CorrelationId == _correlationId);
_result = repository.Find(query).GetAwaiter().GetResult();
}
public void GivenADocumentDbQuerySagaRepository_WhenFindingSaga()
{
_correlationId = Guid.NewGuid();
SagaRepository.Instance.InsertSaga(new SimpleSaga {
CorrelationId = _correlationId
}).GetAwaiter().GetResult();
var repository = new DocumentDbSagaRepository <SimpleSaga>(SagaRepository.Instance.Client, SagaRepository.DatabaseName);
ISagaQuery <SimpleSaga> query = new SagaQuery <SimpleSaga>(x => x.CorrelationId == _correlationId);
_result = repository.Find(query).GetAwaiter().GetResult();
}
public async Task Query_Passes_With_Json_Property_Attribute()
{
// Arrange
var correlationId = Guid.NewGuid();
_ids.Add(correlationId);
SagaRepository.Instance.InsertSaga(new SimpleSagaResource {
CorrelationId = correlationId
}, false).GetAwaiter().GetResult();
ISagaQuery <SimpleSagaResource> query = new SagaQuery <SimpleSagaResource>(x => x.CorrelationId == correlationId);
// Act
var repository = new DocumentDbSagaRepository <SimpleSagaResource>(SagaRepository.Instance.Client, SagaRepository.DatabaseName);
var result = repository.Find(query).GetAwaiter().GetResult();
// Assert
Assert.That(result.Single(), Is.EqualTo(correlationId));
}
public async Task Query_Fails_With_Json_Resolver_Rename()
{
// Arrange
var correlationId = Guid.NewGuid();
_ids.Add(correlationId);
SagaRepository.Instance.InsertSaga(new SimpleSaga {
CorrelationId = correlationId
}, true).GetAwaiter().GetResult();
ISagaQuery <SimpleSaga> query = new SagaQuery <SimpleSaga>(x => x.CorrelationId == correlationId);
// Act
var repository = new DocumentDbSagaRepository <SimpleSaga>(SagaRepository.Instance.Client, SagaRepository.DatabaseName, JsonSerializerSettingsExtensions.GetSagaRenameSettings <SimpleSaga>());
var result = repository.Find(query).GetAwaiter().GetResult();
// Assert
Assert.That(result.Any(), Is.False);
}
public async Task Query_Other_Property_Passes_With_Json_Resolver_Rename()
{
// Arrange
var correlationId = Guid.NewGuid();
_ids.Add(correlationId);
var username = Guid.NewGuid().ToString(); // wouldn't actually be a guid, but used this for uniqueness
SagaRepository.Instance.InsertSaga(new SimpleSaga {
CorrelationId = correlationId, Username = username
}, true).GetAwaiter().GetResult();
ISagaQuery <SimpleSaga> query = new SagaQuery <SimpleSaga>(x => x.Username == username);
// Act
var repository = new DocumentDbSagaRepository <SimpleSaga>(SagaRepository.Instance.Client, SagaRepository.DatabaseName, JsonSerializerSettingsExtensions.GetSagaRenameSettings <SimpleSaga>());
var result = repository.Find(query).GetAwaiter().GetResult();
// Assert
Assert.That(result.Single(), Is.EqualTo(correlationId)); // So it does find it
}
public static async Task <Guid?> ShouldContainSaga <TSaga>(this IQuerySagaRepository <TSaga> repository,
Expression <Func <TSaga, bool> > filter,
TimeSpan timeout)
where TSaga : class, ISaga
{
DateTime giveUpAt = DateTime.Now + timeout;
var query = new SagaQuery <TSaga>(filter);
while (DateTime.Now < giveUpAt)
{
var sagas = (await repository.Where(query.FilterExpression).ConfigureAwait(false)).ToList();
if (sagas.Count > 0)
{
return(sagas.Single());
}
await Task.Delay(10).ConfigureAwait(false);
}
return(default(Guid?));
}
/// <summary>
/// Waits until a saga exists with the specified correlationId
/// </summary>
/// <param name="correlationId"></param>
/// <param name="timeout"></param>
/// <returns></returns>
public async Task <Guid?> Exists(Guid correlationId, TimeSpan?timeout = default)
{
if (QuerySagaRepository == null)
{
throw new InvalidOperationException("The repository does not support Query operations");
}
var giveUpAt = DateTime.Now + (timeout ?? TestTimeout);
var query = new SagaQuery <TSaga>(x => x.CorrelationId == correlationId);
while (DateTime.Now < giveUpAt)
{
var saga = (await QuerySagaRepository.Find(query).ConfigureAwait(false)).FirstOrDefault();
if (saga != Guid.Empty)
{
return(saga);
}
await Task.Delay(10).ConfigureAwait(false);
}
return(default);
/// <summary>
/// Waits until at least one saga exists matching the specified filter
/// </summary>
/// <param name="filter"></param>
/// <param name="timeout"></param>
/// <returns></returns>
public async Task <IList <Guid> > Match(Expression <Func <TSaga, bool> > filter, TimeSpan?timeout = default(TimeSpan?))
{
if (_querySagaRepository == null)
{
throw new InvalidOperationException("The repository does not support Query operations");
}
var giveUpAt = DateTime.Now + (timeout ?? _testTimeout);
var query = new SagaQuery <TSaga>(filter);
while (DateTime.Now < giveUpAt)
{
List <Guid> sagas = (await _querySagaRepository.Where(query.FilterExpression).ConfigureAwait(false)).ToList();
if (sagas.Count > 0)
{
return(sagas);
}
await Task.Delay(10).ConfigureAwait(false);
}
return(new List <Guid>());
}
