public async Task Defaults_to_no_ttbr()
{
using (var connection = sqlConnectionFactory.OpenNewConnection().GetAwaiter().GetResult())
{
using (var transaction = connection.BeginTransaction())
{
var transportTransaction = new TransportTransaction();
transportTransaction.Set(connection);
transportTransaction.Set(transaction);
var context = new ContextBag();
context.Set(transportTransaction);
var operation = new TransportOperation(
new OutgoingMessage("1", new Dictionary <string, string>(), new byte[0]),
new UnicastAddressTag(validAddress)
);
await dispatcher.Dispatch(new TransportOperations(operation), transportTransaction, context).ConfigureAwait(false);
transaction.Commit();
}
var expired = await queue.PurgeBatchOfExpiredMessages(connection, 100).ConfigureAwait(false);
Assert.AreEqual(0, expired);
}
}
public void ShouldShallowCloneContextBag()
{
var context = new ContextBag();
context.Set("someKey", "someValue");
var testee = new SubscribeContext(new RootContext(null, null, null), typeof(object), context);
testee.Extensions.Set("someKey", "updatedValue");
testee.Extensions.Set("anotherKey", "anotherValue");
string value;
string anotherValue;
context.TryGet("someKey", out value);
Assert.AreEqual("someValue", value);
Assert.IsFalse(context.TryGet("anotherKey", out anotherValue));
string updatedValue;
string anotherValue2;
testee.Extensions.TryGet("someKey", out updatedValue);
testee.Extensions.TryGet("anotherKey", out anotherValue2);
Assert.AreEqual("updatedValue", updatedValue);
Assert.AreEqual("anotherValue", anotherValue2);
}
private async Task RunTestUsing(GetSagaDelegate getSaga)
{
var sagaId = StoreSagaDocuments();
using (var session = store.OpenAsyncSession().UsingOptimisticConcurrency())
{
var persister = new SagaPersister();
var context = new ContextBag();
context.Set(session);
var synchronizedSession = new RavenDBSynchronizedStorageSession(session);
var sagaData = await getSaga(persister, sagaId, synchronizedSession, context);
Assert.IsNotNull(sagaData);
Assert.AreEqual(42, sagaData.Counter);
Assert.AreEqual("Alpha", sagaData.Name);
await persister.Complete(sagaData, synchronizedSession, context);
await session.SaveChangesAsync();
}
using (var session = store.OpenAsyncSession().UsingOptimisticConcurrency())
{
var dataDocs = await session.Advanced.LoadStartingWithAsync <SagaDataContainer>("CountingSagaDatas/");
var uniqueDocs = await session.Advanced.LoadStartingWithAsync <SagaUniqueIdentity>("Raven3Sagas-");
Assert.IsEmpty(dataDocs);
Assert.IsEmpty(uniqueDocs);
}
}
public async Task When_in_transaction_scope_with_sql_connection_should_hook_up_to_that_connection()
{
var data = new TimeoutData
{
Time = DateTime.Now,
OwningTimeoutManager = "MyTestEndpoint",
};
var contextBag = new ContextBag();
using (var tx = new TransactionScope())
{
var connection = (SqlConnection)((SessionFactoryImpl)sessionFactory).ConnectionProvider.GetConnection();
var transaction = new TransportTransaction();
transaction.Set(Transaction.Current);
transaction.Set(connection);
contextBag.Set(transaction);
await persister.Add(data, contextBag).ConfigureAwait(false);
Assert.AreEqual(Guid.Empty, Transaction.Current.TransactionInformation.DistributedIdentifier);
tx.Complete();
}
using (var session = sessionFactory.OpenSession())
{
Assert.NotNull(session.Get <TimeoutEntity>(new Guid(data.Id)));
}
}
public ContainerHolder ResolveAndSetIfAvailable(ContextBag context)
{
if (context.TryGet <ContainerHolder>(out var containerHolder))
{
return(containerHolder);
}
ContainerInformation?information;
if (context.TryGet <ContainerInformation>(out var containerInformation))
{
information = containerInformation;
}
else
{
information = defaultContainerInformation;
}
if (!information.HasValue)
{
return(null);
}
var informationValue = information.Value;
containerHolder = new ContainerHolder(provideCosmosClient.Client.GetContainer(databaseName, informationValue.ContainerName), informationValue.PartitionKeyPath);
context.Set(containerHolder);
return(containerHolder);
}
public async Task is_delayed_delayed()
{
var bag = new ContextBag();
bool invoked = false;
var handler = new MessageHandler((first, second, ctx) =>
{
invoked = true;
return(Task.CompletedTask);
}, typeof(DelayedHandler));
var context = new Moq.Mock <IInvokeHandlerContext>();
var builder = new Moq.Mock <IBuilder>();
var channel = new Moq.Mock <IDelayedChannel>();
var next = new Moq.Mock <Func <PipelineTerminator <IInvokeHandlerContext> .ITerminatingContext, Task> >();
var container = new Moq.Mock <IContainer>();
bag.Set(container.Object);
container.Setup(x => x.Resolve <IDelayedChannel>()).Returns(channel.Object);
context.Setup(x => x.MessageHandler).Returns(handler);
context.Setup(x => x.Builder).Returns(builder.Object);
context.Setup(x => x.Extensions).Returns(bag);
context.Setup(x => x.MessageBeingHandled).Returns(new DelayedMessage());
context.Setup(x => x.Headers).Returns(new Dictionary <string, string>());
await _terminator.Invoke(context.Object, next.Object);
Assert.False(invoked);
channel.Verify(x => x.AddToQueue(Moq.It.IsAny <string>(), Moq.It.IsAny <IDelayedMessage>(), Moq.It.IsAny <string>()), Moq.Times.Once);
// Posibly optional
channel.Verify(x => x.Age(Moq.It.IsAny <string>(), Moq.It.IsAny <string>()), Moq.Times.Once);
channel.Verify(x => x.Size(Moq.It.IsAny <string>(), Moq.It.IsAny <string>()), Moq.Times.Once);
}
static ContextBag CreateContextBag(string messageId)
{
var contextBag = new ContextBag();
contextBag.Set(new IncomingMessage(messageId, new Dictionary <string, string>(), new byte[0]));
return(contextBag);
}
public Task persistence_uow_bag_stored_on_fail()
{
var bag = new ContextBag();
bag.Set("test", "test");
var context = new Moq.Mock <IIncomingLogicalMessageContext>();
var next = new Moq.Mock <Func <Task> >();
var builder = new Moq.Mock <IBuilder>();
var uow = new Moq.Mock <IApplicationUnitOfWork>();
builder.Setup(x => x.BuildAll <IApplicationUnitOfWork>()).Returns(new IApplicationUnitOfWork[] { uow.Object });
context.Setup(x => x.MessageId).Returns("1");
context.Setup(x => x.Message).Returns(new LogicalMessage(new NServiceBus.Unicast.Messages.MessageMetadata(typeof(object)), new object()));
context.Setup(x => x.Extensions).Returns(bag);
context.Setup(x => x.Builder).Returns(builder.Object);
context.Setup(x => x.Headers).Returns(new Dictionary <string, string>());
context.Setup(x => x.MessageHeaders)
.Returns(new Dictionary <string, string> {
[Headers.MessageIntent] = MessageIntentEnum.Send.ToString()
});
uow.Setup(x => x.End(null)).Throws(new Exception("test"));
uow.Setup(x => x.Bag).Returns(bag);
Assert.ThrowsAsync <Exception>(() => _uow.Invoke(context.Object, next.Object));
_persistence.Verify(x => x.Save("1", uow.Object.GetType(), bag), Moq.Times.Once);
_persistence.Verify(x => x.Clear("1"), Moq.Times.Never);
next.Verify(x => x(), Moq.Times.Once);
return(Task.CompletedTask);
}
public async Task Delivery_constraint_is_respected()
{
using (var connection = sqlConnectionFactory.OpenNewConnection().GetAwaiter().GetResult())
{
using (var transaction = connection.BeginTransaction())
{
var transportTransaction = new TransportTransaction();
transportTransaction.Set(SettingsKeys.TransportTransactionSqlConnectionKey, connection);
transportTransaction.Set(SettingsKeys.TransportTransactionSqlTransactionKey, transaction);
var context = new ContextBag();
context.Set(transportTransaction);
var operation = new TransportOperation(
new OutgoingMessage("1", new Dictionary <string, string>(), new byte[0]),
new UnicastAddressTag(validAddress),
DispatchConsistency.Default,
new List <DeliveryConstraint>
{
new DiscardIfNotReceivedBefore(TimeSpan.FromMinutes(-1)) //Discard immediately
}
);
await dispatcher.Dispatch(new TransportOperations(operation), transportTransaction, context).ConfigureAwait(false);
transaction.Commit();
}
var message = await queue.TryReceive(connection, null).ConfigureAwait(false);
Assert.IsTrue(message.Message.Expired);
}
}
public static ContextBag CreateContextWithAsyncSessionPresent(this RavenDBPersistenceTestBase testBase, out IAsyncDocumentSession session)
{
var context = new ContextBag();
session = testBase.OpenAsyncSession();
context.Set(session);
return context;
}
public async Task persistence_uow_retreive_bag()
{
var bag = new ContextBag();
bag.Set("test", "test");
var context = new Moq.Mock <IIncomingLogicalMessageContext>();
var next = new Moq.Mock <Func <Task> >();
var builder = new Moq.Mock <IBuilder>();
var uow = new FakeUnitOfWork();
builder.Setup(x => x.BuildAll <IApplicationUnitOfWork>()).Returns(new IApplicationUnitOfWork[] { uow });
context.Setup(x => x.MessageId).Returns("1");
context.Setup(x => x.Message).Returns(new LogicalMessage(new NServiceBus.Unicast.Messages.MessageMetadata(typeof(object)), new object()));
context.Setup(x => x.Extensions).Returns(bag);
context.Setup(x => x.Builder).Returns(builder.Object);
context.Setup(x => x.Headers).Returns(new Dictionary <string, string>());
context.Setup(x => x.MessageHeaders)
.Returns(new Dictionary <string, string> {
[Headers.MessageIntent] = MessageIntentEnum.Send.ToString()
});
_persistence.Setup(x => x.Remove("1", uow.GetType())).Returns(Task.FromResult(bag));
await _uow.Invoke(context.Object, next.Object);
next.Verify(x => x(), Moq.Times.Once);
string test;
Assert.True(uow.Bag.TryGet <string>("test", out test));
Assert.AreEqual("test", test);
_persistence.Verify(x => x.Save("1", uow.GetType(), bag), Moq.Times.Once);
_persistence.Verify(x => x.Clear("1"), Moq.Times.Once);
}
public async Task <T> Get <T>(string propertyName, object propertyValue, SynchronizedStorageSession session, ContextBag context)
where T : class, IContainSagaData
{
var documentSession = session.RavenSession();
var lookupId = SagaUniqueIdentity.FormatId(typeof(T), propertyName, propertyValue);
var lookup = await documentSession
.Include("SagaDocId") //tell raven to pull the saga doc as well to save us a round-trip
.LoadAsync <SagaUniqueIdentity>(lookupId)
.ConfigureAwait(false);
if (lookup != null)
{
documentSession.Advanced.Evict(lookup);
// If we have a saga id we can just load it, should have been included in the round-trip already
var container = await documentSession.LoadAsync <SagaDataContainer>(lookup.SagaDocId).ConfigureAwait(false);
if (container != null)
{
if (container.IdentityDocId == null)
{
container.IdentityDocId = lookupId;
}
context.Set($"{SagaContainerContextKeyPrefix}{container.Data.Id}", container);
return((T)container.Data);
}
}
return(default(T));
}
public async Task Diagnostic_headers_are_ignored()
{
using (var connection = sqlConnectionFactory.OpenNewConnection().GetAwaiter().GetResult())
{
using (var transaction = connection.BeginTransaction())
{
var transportTransaction = new TransportTransaction();
transportTransaction.Set(SettingsKeys.TransportTransactionSqlConnectionKey, connection);
transportTransaction.Set(SettingsKeys.TransportTransactionSqlTransactionKey, transaction);
var context = new ContextBag();
context.Set(transportTransaction);
var headers = new Dictionary <string, string>
{
[Headers.TimeToBeReceived] = TimeSpan.FromMinutes(-1).ToString()
};
var operation = new TransportOperation(
new OutgoingMessage("1", headers, new byte[0]),
new UnicastAddressTag(ValidAddress)
);
await dispatcher.Dispatch(new TransportOperations(operation), transportTransaction).ConfigureAwait(false);
transaction.Commit();
}
var message = await queue.TryReceive(connection, null).ConfigureAwait(false);
Assert.IsFalse(message.Message.Expired);
}
}
public static ContextBag GetContextBag(this IMessage amqpMessage)
{
var contextBag = new ContextBag();
contextBag.Set(amqpMessage);
return(contextBag);
}
public async Task Diagnostic_headers_are_ignored()
{
using (var connection = sqlConnectionFactory.OpenNewConnection().GetAwaiter().GetResult())
{
using (var transaction = connection.BeginTransaction())
{
var transportTransaction = new TransportTransaction();
transportTransaction.Set(connection);
transportTransaction.Set(transaction);
var context = new ContextBag();
context.Set(transportTransaction);
var headers = new Dictionary <string, string>
{
[Headers.TimeToBeReceived] = TimeSpan.FromMinutes(-1).ToString()
};
var operation = new TransportOperation(
new OutgoingMessage("1", headers, new byte[0]),
new UnicastAddressTag(validAddress)
);
await dispatcher.Dispatch(new TransportOperations(operation), transportTransaction, context).ConfigureAwait(false);
transaction.Commit();
}
var expired = await queue.PurgeBatchOfExpiredMessages(connection, 100).ConfigureAwait(false);
Assert.AreEqual(0, expired);
}
}
/// <summary>
/// Initializes a new TestableCosmosSynchronizedStorageSession with a partition key.
/// </summary>
public TestableCosmosSynchronizedStorageSession(PartitionKey partitionKey)
{
var contextBag = new ContextBag();
contextBag.Set(partitionKey);
((IWorkWithSharedTransactionalBatch)this).CurrentContextBag = contextBag;
}
public async Task When_in_transaction_scope_add_should_commit_when_scope_is_complete()
{
var data = new TimeoutData
{
Time = DateTime.Now.AddYears(-1),
OwningTimeoutManager = "MyTestEndpoint",
};
var contextBag = new ContextBag();
using (var tx = new TransactionScope())
{
var transaction = new TransportTransaction();
transaction.Set(Transaction.Current);
contextBag.Set(transaction);
await persister.Add(data, contextBag).ConfigureAwait(false);
tx.Complete();
}
using (var session = sessionFactory.OpenSession())
{
Assert.NotNull(session.Get <TimeoutEntity>(new Guid(data.Id)));
}
}
public async Task retries_are_set()
{
var bag = new ContextBag();
bag.Set(Defaults.Retries, 1);
var context = new Moq.Mock <IIncomingLogicalMessageContext>();
var next = new Moq.Mock <Func <Task> >();
var builder = new Moq.Mock <IBuilder>();
var uow = new FakeUnitOfWork();
builder.Setup(x => x.BuildAll <IApplicationUnitOfWork>()).Returns(new IApplicationUnitOfWork[] { uow });
context.Setup(x => x.MessageId).Returns("1");
context.Setup(x => x.Message).Returns(new LogicalMessage(new NServiceBus.Unicast.Messages.MessageMetadata(typeof(object)), new object()));
context.Setup(x => x.Extensions).Returns(bag);
context.Setup(x => x.Builder).Returns(builder.Object);
context.Setup(x => x.Headers).Returns(new Dictionary <string, string>());
context.Setup(x => x.MessageHeaders)
.Returns(new Dictionary <string, string> {
[Headers.MessageIntent] = MessageIntentEnum.Send.ToString()
});
await _uow.Invoke(context.Object, next.Object);
next.Verify(x => x(), Moq.Times.Once);
Assert.AreEqual(1, uow.Retries);
}
static ContextBag GetContextWithRabbitMqPriority(byte priority)
{
var contextBag = new ContextBag();
contextBag.Set(new RabbitMQMessagePriority(priority));
return(contextBag);
}
public async Task <T> Get <T>(string propertyName, object propertyValue, SynchronizedStorageSession session, ContextBag context)
where T : class, IContainSagaData
{
var documentSession = session.RavenSession();
var lookupId = SagaUniqueIdentity.FormatId(typeof(T), propertyName, propertyValue);
//store it in the context to be able to optimize deletes for legacy sagas that don't have the id in metadata
context.Set(UniqueDocIdKey, lookupId);
var lookup = await documentSession
.Include("SagaDocId") //tell raven to pull the saga doc as well to save us a round-trip
.LoadAsync <SagaUniqueIdentity>(lookupId)
.ConfigureAwait(false);
if (lookup != null)
{
documentSession.Advanced.Evict(lookup);
return(lookup.SagaDocId != null
? await documentSession.LoadAsync <T>(lookup.SagaDocId).ConfigureAwait(false) //if we have a saga id we can just load it
: await Get <T>(lookup.SagaId, session, context).ConfigureAwait(false)); //if not this is a saga that was created pre 3.0.4 so we fallback to a get instead
}
return(default(T));
}
public async Task Defaults_to_no_ttbr()
{
using (var connection = sqlConnectionFactory.OpenNewConnection().GetAwaiter().GetResult())
{
using (var transaction = connection.BeginTransaction())
{
var transportTransaction = new TransportTransaction();
transportTransaction.Set(SettingsKeys.TransportTransactionSqlConnectionKey, connection);
transportTransaction.Set(SettingsKeys.TransportTransactionSqlTransactionKey, transaction);
var context = new ContextBag();
context.Set(transportTransaction);
var operation = new TransportOperation(
new OutgoingMessage("1", new Dictionary <string, string>(), new byte[0]),
new UnicastAddressTag(ValidAddress)
);
await dispatcher.Dispatch(new TransportOperations(operation), transportTransaction).ConfigureAwait(false);
transaction.Commit();
}
var message = await queue.TryReceive(connection, null).ConfigureAwait(false);
Assert.IsFalse(message.Message.Expired);
}
}
public static ContextBag CreateContextWithSessionPresent(this MartenPersistenceTestBase testBase, out IDocumentSession session)
{
var context = new ContextBag();
session = testBase.OpenSession();
context.Set(session);
return(context);
}
public Task <TestSaga08.SagaData08> FindBy(SomeOtherMessage message, SynchronizedStorageSession storageSession, ReadOnlyContextBag context)
{
Context.FinderUsed = true;
var bag = new ContextBag();
bag.Set(context.Get <IncomingMessage>());
return(SagaPersister.Get <TestSaga08.SagaData08>("Property", "Test", storageSession, bag));
}
public static ContextBag CreateContextWithAsyncSessionPresent(this RavenDBPersistenceTestBase testBase, out IAsyncDocumentSession session)
{
var context = new ContextBag();
session = testBase.OpenAsyncSession();
context.Set(session);
return(context);
}
static TSagaData SetConcurrency <TSagaData>(Concurrency <TSagaData> result, ContextBag context)
where TSagaData : IContainSagaData
{
if (!EqualityComparer <TSagaData> .Default.Equals(result.Data, default(TSagaData)))
{
context.Set("NServiceBus.Persistence.Sql.Concurrency", result.Version);
}
return(result.Data);
}
public void ShouldAllowMonkeyPatching()
{
var contextBag = new ContextBag();
contextBag.Set("MonkeyPatch", "some string");
((ReadOnlyContextBag)contextBag).TryGet("MonkeyPatch", out string theValue);
Assert.AreEqual("some string", theValue);
}
static void SetDoNotEnforceBestPractices(this ContextBag context)
{
var bestPracticesOptions = new EnforceBestPracticesOptions
{
Enabled = false
};
context.Set(bestPracticesOptions);
}
public void Can_pass_additional_information_via_context_bag()
{
var contextBag = new ContextBag();
contextBag.Set("MyKey", "MyValue");
var context = new ErrorContext(new Exception(), new Dictionary <string, string>(), "ID", new byte[0], new TransportTransaction(), 0, contextBag);
Assert.AreEqual("MyValue", context.Extensions.Get <string>("MyKey"));
}
static void SetEntry(ContextBag context, Guid sagaId, Entry value)
{
if (context.TryGet(ContextKey, out Dictionary <Guid, Entry> entries) == false)
{
entries = new Dictionary <Guid, Entry>();
context.Set(ContextKey, entries);
}
entries[sagaId] = value;
}
public Task<OutboxTransaction> BeginTransaction(ContextBag context)
{
var session = documentStore.OpenAsyncSession();
session.Advanced.UseOptimisticConcurrency = true;
context.Set(session);
var transaction = new RavenDBOutboxTransaction(session);
return Task.FromResult<OutboxTransaction>(transaction);
}
protected IncomingMessage SimulateIncomingMessage(ContextBag context, string messageId = null)
{
messageId = messageId ?? Guid.NewGuid().ToString("N");
var incomingMessage = new IncomingMessage(messageId, new Dictionary <string, string>(), new byte[0]);
context.Set(incomingMessage);
return(incomingMessage);
}
public async Task <IActionResult> Invoke(HttpRequest request, string messageType, ILogger logger, IAsyncCollector <string> collector, ExecutionContext executionContext)
{
var messageId = Guid.NewGuid().ToString("N");
var headers = new Dictionary <string, string> {
[Headers.EnclosedMessageTypes] = messageType
};
foreach (var httpHeader in request.Headers)
{
headers[httpHeader.Key] = httpHeader.Value;
}
var memoryStream = new MemoryStream();
await request.Body.CopyToAsync(memoryStream);
var body = memoryStream.ToArray(); //JsonConvert.DeserializeObject(memoryStream.ToArray(), typeof(PlaceOrder)); // TODO: hardcoded, needs to be determined
var rootContext = new ContextBag();
if (collector == null)
{
collector = new FakeCollector <string>();
}
rootContext.Set(collector);
var messageContext = new MessageContext(messageId, headers, body, new TransportTransaction(), new CancellationTokenSource(), rootContext);
var instance = await GetEndpoint(logger, executionContext);
try
{
await instance.PushMessage(messageContext);
}
catch (Exception ex)
{
if (moveFailedMessagesToError)
{
var errorContext = new ErrorContext(ex, headers, messageId, body, new TransportTransaction(), 0);
var result = await instance.PushError(errorContext);
if (result == ErrorHandleResult.RetryRequired)
{
throw;
}
return(new AcceptedResult());
}
throw;
}
return(new OkResult());
}
public void ShouldAllowMonkeyPatching()
{
var contextBag = new ContextBag();
contextBag.Set("MonkeyPatch", "some string");
string theValue;
((ReadOnlyContextBag) contextBag).TryGet("MonkeyPatch", out theValue);
Assert.AreEqual("some string", theValue);
}
async Task ProcessFile(DirectoryBasedTransaction transaction, string messageId)
{
try
{
string[] message = File.ReadAllLines(transaction.FileToProcess);
string bodyPath = message.First();
string json = string.Join("", message.Skip(1));
Dictionary<string, string> headers = HeaderSerializer.DeSerialize(json);
string ttbrString;
if (headers.TryGetValue(Headers.TimeToBeReceived, out ttbrString))
{
TimeSpan ttbr = TimeSpan.Parse(ttbrString);
//file.move preserves create time
DateTime sentTime = File.GetCreationTimeUtc(transaction.FileToProcess);
if (sentTime + ttbr < DateTime.UtcNow)
{
transaction.Commit();
return;
}
}
CancellationTokenSource tokenSource = new CancellationTokenSource();
using (FileStream bodyStream = new FileStream(bodyPath, FileMode.Open))
{
ContextBag context = new ContextBag();
context.Set(transaction);
PushContext pushContext = new PushContext(messageId, headers, bodyStream, transaction, tokenSource, context);
await pipeline(pushContext).ConfigureAwait(false);
}
if (tokenSource.IsCancellationRequested)
{
transaction.Rollback();
return;
}
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
}
}
