public async Task TimeoutsAreNotRemovedIfTheyAreNotMarkedAsComplete() { var theFuture = DateTimeOffset.Now.AddMinutes(1); await _timeoutManager.Defer(theFuture, HeadersWith("i know u"), EmptyBody()); RebusTimeMachine.FakeIt(theFuture + TimeSpan.FromSeconds(1)); using (var result = await _timeoutManager.GetDueMessages()) { var dueTimeoutsInTheFuture = result.ToList(); Assert.That(dueTimeoutsInTheFuture.Count, Is.EqualTo(1)); } using (var result = await _timeoutManager.GetDueMessages()) { var dueTimeoutsInTheFuture = result.ToList(); Assert.That(dueTimeoutsInTheFuture.Count, Is.EqualTo(1)); // mark as complete dueTimeoutsInTheFuture[0].MarkAsCompleted(); } using (var result = await _timeoutManager.GetDueMessages()) { var dueTimeoutsInTheFuture = result.ToList(); Assert.That(dueTimeoutsInTheFuture.Count, Is.EqualTo(0)); } }
public async Task UpdatesTimeOfLastRead() { const string knownId = "known id"; using (var source = new MemoryStream(new byte[0])) { await _storage.Save(knownId, source); } var hadLastReadTime = (await _storage.ReadMetadata(knownId)).ContainsKey(MetadataKeys.ReadTime); Assert.That(hadLastReadTime, Is.False, "Did not expect the {0} key to be set", MetadataKeys.ReadTime); var justSomeTime = new DateTimeOffset(1.January(2016)); RebusTimeMachine.FakeIt(justSomeTime); _storage.Read(knownId).Result.Dispose(); var metadata = await _storage.ReadMetadata(knownId); Assert.That(metadata.ContainsKey(MetadataKeys.ReadTime), Is.True); var readTimeMetadata = metadata[MetadataKeys.ReadTime]; var readTime = DateTimeOffset.Parse(readTimeMetadata); Assert.That(readTime, Is.EqualTo(justSomeTime), $"Expected that the '{MetadataKeys.ReadTime}' metadata value '{readTimeMetadata}' would equal {justSomeTime} when passed to DateTimeOffset.Parse(...)"); }
/// <summary> /// Queries the underlying table and returns due timeouts, removing them at the same time /// </summary> public DueTimeoutsResult GetDueTimeouts() { var dueTimeouts = new List <DueTimeout>(); using (var connection = factory.OpenConnection()) using (var command = connection.CreateCommand()) { const string sql = @" SELECT ""id"", ""time_to_return"", ""correlation_id"", ""saga_id"", ""reply_to"", ""custom_data"" FROM ""{0}"" WHERE ""time_to_return"" <= @current_time ORDER BY ""time_to_return"" ASC "; command.CommandText = string.Format(sql, timeoutsTableName); command.AddParameter("current_time", RebusTimeMachine.Now()); using (var reader = command.ExecuteReader()) { while (reader.Read()) { var sqlTimeout = DueAdoNetTimeout.Create(MarkAsProcessed, timeoutsTableName, reader); dueTimeouts.Add(sqlTimeout); } } } return(new DueTimeoutsResult(dueTimeouts)); }
public IEnumerable <Timeout.Timeout> RemoveDueTimeouts() { using (var session = store.OpenSession()) { var dueTimeouts = session.Query <RavenTimeout>() .Customize(x => x.WaitForNonStaleResultsAsOfLastWrite()) .Where(x => x.Time <= RebusTimeMachine.Now()).OrderBy(x => x.Time) .ToList(); foreach (var timeout in dueTimeouts) { var loadedTimeout = session.Load <RavenTimeout>(timeout.Id); session.Delete(loadedTimeout); } var rebusTimeouts = dueTimeouts.Select(storedTimeout => new Timeout.Timeout { CorrelationId = storedTimeout.CorrelationId, SagaId = storedTimeout.SagaId, TimeToReturn = storedTimeout.Time, CustomData = storedTimeout.Data, ReplyTo = storedTimeout.ReplyTo }).ToList(); session.SaveChanges(); return(rebusTimeouts); } }
/// <summary> /// Retrieves all due timeouts /// </summary> public DueTimeoutsResult GetDueTimeouts() { lock (listLock) { var timeoutsToRemove = timeouts .Where(t => RebusTimeMachine.Now() >= t.TimeToReturn) .ToList(); log.Debug("Returning {0} timeouts", timeoutsToRemove.Count); return(new DueTimeoutsResult(timeoutsToRemove .Select(t => new DueInMemoryTimeout(t.ReplyTo, t.CorrelationId, t.TimeToReturn, t.SagaId, t.CustomData, () => { lock (listLock) { log.Debug("Removing timeout {0} -> {1}: {2}", t.TimeToReturn, t.ReplyTo, t.CustomData); timeouts.Remove(t); } })) .ToList())); } }
public IEnumerable <Timeout.Timeout> RemoveDueTimeouts() { var collection = database.GetCollection(collectionName); var gotResult = true; do { var result = collection.FindAndRemove(Query.LTE("time", RebusTimeMachine.Now()), SortBy.Ascending("time")); if (result != null && result.ModifiedDocument != null) { var document = result.ModifiedDocument; yield return(new Timeout.Timeout { CorrelationId = document["corr_id"].AsString, SagaId = document["saga_id"].AsGuid, CustomData = document["data"] != BsonNull.Value ? document["data"].AsString : "", ReplyTo = document["reply_to"].AsString, TimeToReturn = document["time"].AsDateTime, }); } else { gotResult = false; } } while (gotResult); }
public async Task TimeoutsAreNotRemovedIfTheyAreNotMarkedAsComplete() { var theFuture = RebusTime.Now.AddMinutes(1); await _timeoutManager.Defer(theFuture, HeadersWith("i know u"), EmptyBody()); RebusTimeMachine.FakeIt(theFuture + TimeSpan.FromSeconds(1)); using (var result = await _timeoutManager.GetDueMessages()) { var dueTimeoutsInTheFuture = result.ToList(); Assert.That(dueTimeoutsInTheFuture.Count, Is.EqualTo(1), "Did not get the expected number of timeouts - debug info: {0}", _factory.GetDebugInfo()); } using (var result = await _timeoutManager.GetDueMessages()) { var dueTimeoutsInTheFuture = result.ToList(); Assert.That(dueTimeoutsInTheFuture.Count, Is.EqualTo(1), "Did not get the expected number of timeouts - debug info: {0}", _factory.GetDebugInfo()); // mark as complete await dueTimeoutsInTheFuture[0].MarkAsCompleted(); } using (var result = await _timeoutManager.GetDueMessages()) { var dueTimeoutsInTheFuture = result.ToList(); Assert.That(dueTimeoutsInTheFuture.Count, Is.EqualTo(0), "Did not get the expected number of timeouts - debug info: {0}", _factory.GetDebugInfo()); } }
public DueTimeoutsResult GetDueTimeouts() { using (var session = store.OpenSession()) { var now = RebusTimeMachine.Now(); var dueTimeouts = session.Query <RavenTimeout>() .Customize(x => x.WaitForNonStaleResultsAsOfLastWrite()) .Where(x => x.Time <= now).OrderBy(x => x.Time) .ToList(); var rebusTimeouts = dueTimeouts .Select(storedTimeout => new DueRavenTimeout(storedTimeout.ReplyTo, storedTimeout.CorrelationId, storedTimeout.Time, storedTimeout.SagaId, storedTimeout.Data, store, storedTimeout.Id)) .ToList(); session.SaveChanges(); return(new DueTimeoutsResult(rebusTimeouts)); } }
public async Task CanGetStandardMetada() { var fakeTime = new DateTimeOffset(17.June(2016)); RebusTimeMachine.FakeIt(fakeTime); const string knownId = "known id"; var data = new byte[] { 1, 2, 3 }; using (var source = new MemoryStream(data)) { await _storage.Save(knownId, source); } var readMetadata = await _storage.ReadMetadata(knownId); // special case: zipped data has different size (and is actually bigger in this case :)) if (_storage is ZippingDataBusStorageDecorator) { Assert.That(readMetadata[MetadataKeys.Length], Is.EqualTo("23")); } else { Assert.That(readMetadata[MetadataKeys.Length], Is.EqualTo("3")); } Assert.That(readMetadata[MetadataKeys.SaveTime], Is.EqualTo(fakeTime.ToString("O"))); }
/// <summary> /// Internal send method - this one must not change the headers! /// </summary> internal void InternalSend(List <string> destinations, Message messageToSend, ITransactionContext transactionContext, bool published = false) { messageLogger.LogSend(destinations, messageToSend); var transportMessage = serializeMessages.Serialize(messageToSend); InternalSend(destinations, transportMessage, transactionContext); if (configureAdditionalBehavior.AuditMessages && published) { transportMessage.Headers[Headers.AuditReason] = Headers.AuditReasons.Published; if (configureAdditionalBehavior.OneWayClientMode) { transportMessage.Headers[Headers.AuditPublishedByOneWayClient] = ""; } else { transportMessage.Headers[Headers.AuditSourceQueue] = GetInputQueueAddress(); } transportMessage.Headers[Headers.AuditMessageCopyTime] = RebusTimeMachine.Now().ToString("u"); var auditQueueName = configureAdditionalBehavior.AuditQueueName; InternalSend(new List <string> { auditQueueName }, transportMessage, transactionContext); events.RaiseMessageAudited(this, transportMessage); } }
public void _SetUp() { RebusTimeMachine.Reset(); _disposables.Clear(); SetUp(); }
/// <summary> /// Queries the underlying table and returns due timeouts, removing them at the same time /// </summary> public DueTimeoutsResult GetDueTimeouts() { var connection = new SqlConnection(connectionString); connection.Open(); var transaction = connection.BeginTransaction(); var dueTimeouts = new List <DueTimeout>(); using (var command = connection.CreateCommand()) { command.Transaction = transaction; command.CommandText = string.Format( @" select id, time_to_return, correlation_id, saga_id, reply_to, custom_data from [{0}] with (updlock, readpast, rowlock) where time_to_return <= @current_time order by time_to_return asc ", timeoutsTableName); command.Parameters.AddWithValue("current_time", RebusTimeMachine.Now()); using (var reader = command.ExecuteReader()) { while (reader.Read()) { var id = (long)reader["id"]; var correlationId = (string)reader["correlation_id"]; var sagaId = (Guid)reader["saga_id"]; var replyTo = (string)reader["reply_to"]; var timeToReturn = (DateTime)reader["time_to_return"]; var customData = (string)(reader["custom_data"] != DBNull.Value ? reader["custom_data"] : ""); var sqlTimeout = new DueSqlTimeout(id, replyTo, correlationId, timeToReturn, sagaId, customData, timeoutsTableName, connection, transaction); dueTimeouts.Add(sqlTimeout); } } return(new DueTimeoutsResult(dueTimeouts, () => { transaction.Commit(); transaction.Dispose(); connection.Dispose(); })); } }
public void _SetUp() { RebusTimeMachine.Reset(); AdjustLogging(LogLevel.Debug); _disposables.Clear(); SetUp(); }
public IEnumerable <Timeout.Timeout> RemoveDueTimeouts() { lock (listLock) { var timeoutsToRemove = timeouts.Where(t => RebusTimeMachine.Now() >= t.TimeToReturn).ToList(); timeoutsToRemove.ForEach(t => timeouts.Remove(t)); return(timeoutsToRemove); } }
/// <summary> /// Gets all timeouts that are due by now. Doesn't remove the timeouts or change them or anything, /// each individual timeout can be marked as processed by calling <see cref="DueTimeout.MarkAsProcessed"/> /// </summary> public IEnumerable <DueTimeout> GetDueTimeouts() { var result = collection.Find(Query.LTE(TimeProperty, RebusTimeMachine.Now())) .SetSortOrder(SortBy.Ascending(TimeProperty)); return(result .Select(r => new DueMongoTimeout(r[ReplyToProperty].AsString, GetString(r, CorrIdProperty), r[TimeProperty].ToUniversalTime(), GetGuid(r, SagaIdProperty), GetString(r, DataProperty), collection, (ObjectId)r[IdProperty]))); }
public async Task GetQueueVisibilityDelayOrNull_StillReturnsPositiveTimespans() { var sendInstant = DateTimeOffset.Now; var deferDate = sendInstant.AddMilliseconds(350); RebusTimeMachine.FakeIt(sendInstant); var result = AzureStorageQueuesTransport.GetQueueVisibilityDelayOrNull(new Dictionary <string, string> { { Headers.DeferredUntil, deferDate.ToString("O") } }); RebusTimeMachine.Reset(); Assert.AreEqual(result, TimeSpan.FromMilliseconds(350)); }
static void PossiblyCopyToAuditQueue(string auditQueueName, Exception exceptionOrNull, IBus bus, ReceivedTransportMessage message) { // if an error occurred, don't do anything if (exceptionOrNull != null) { return; } // this one will always be non-null - but still if (TransactionContext.Current == null) { log.Warn("Auditor called outside of a proper transaction context!!! This must be an error."); return; } var rebusBus = bus as RebusBus; if (rebusBus == null) { log.Warn("Current IBus is not a RebusBus, it's a {0} - cannot use {0} for auditing, sorry!", bus.GetType().Name); return; } using (var txc = ManagedTransactionContext.Get()) { var messageCopy = message.ToForwardableMessage(); messageCopy.Headers[Headers.AuditReason] = Headers.AuditReasons.Handled; messageCopy.Headers[Headers.AuditSourceQueue] = rebusBus.GetInputQueueAddress(); messageCopy.Headers[Headers.AuditMessageCopyTime] = RebusTimeMachine.Now().ToString("u"); rebusBus.InternalSend(new List <string> { auditQueueName }, messageCopy, txc.Context); var rebusEvents = rebusBus.Events as RebusEvents; if (rebusEvents == null) { log.Warn( "Current IRebusEvents is not a RebusEvents, it's a {0} - cannot use {0} for raising auditing events, sorry! (the message was properly audited though, it just turned out to be impossible to raise the MessageAudited event!)"); return; } rebusEvents.RaiseMessageAudited(rebusBus, messageCopy); } }
public void Handle(TimeoutRequest message) { var currentMessageContext = MessageContext.GetCurrent(); var newTimeout = new Timeout { SagaId = message.SagaId, CorrelationId = message.CorrelationId, ReplyTo = currentMessageContext.ReturnAddress, TimeToReturn = RebusTimeMachine.Now() + message.Timeout, CustomData = message.CustomData, }; storeTimeouts.Add(newTimeout); log.Info("Added new timeout: {0}", newTimeout); }
public void LogsAfterSilencePeriodIsOver() { var now = DateTime.UtcNow; var ignorant = new Ignorant { SilencePeriods = new[] { TimeSpan.FromMinutes(1) } }; RebusTimeMachine.FakeIt(now); var first = ignorant.IsToBeIgnored(new ApplicationException("hej")); RebusTimeMachine.FakeIt(now + TimeSpan.FromMinutes(1.1)); var second = ignorant.IsToBeIgnored(new ApplicationException("hej")); Assert.That(first, Is.True); Assert.That(second, Is.False); }
public IEnumerable <Timeout.Timeout> RemoveDueTimeouts() { using (var connection = new SqlConnection(connectionString)) { connection.Open(); var dueTimeouts = new List <Timeout.Timeout>(); using (var command = connection.CreateCommand()) { command.CommandText = string.Format( @"select time_to_return, correlation_id, saga_id, reply_to, custom_data from [{0}] where time_to_return <= @current_time", timeoutsTableName); command.Parameters.AddWithValue("current_time", RebusTimeMachine.Now()); using (var reader = command.ExecuteReader()) { while (reader.Read()) { var correlationId = (string)reader["correlation_id"]; var sagaId = (Guid)reader["saga_id"]; var replyTo = (string)reader["reply_to"]; var timeToReturn = (DateTime)reader["time_to_return"]; var customData = (string)(reader["custom_data"] != DBNull.Value ? reader["custom_data"] : ""); dueTimeouts.Add(new Timeout.Timeout { CorrelationId = correlationId, SagaId = sagaId, ReplyTo = replyTo, TimeToReturn = timeToReturn, CustomData = customData, }); } } } dueTimeouts.ForEach(t => DeleteTimeout(t, connection)); return(dueTimeouts); } }
public void Handle(TimeoutRequest message) { var currentMessageContext = MessageContext.GetCurrent(); if (string.IsNullOrWhiteSpace(currentMessageContext.ReturnAddress)) { throw new InvalidOperationException("TimeoutRequest received with no ReturnAddress header set. No way to return message when timeout elapses."); } var newTimeout = new Timeout.Timeout(currentMessageContext.ReturnAddress, message.CorrelationId, RebusTimeMachine.Now() + message.Timeout, message.SagaId, message.CustomData); storeTimeouts.Add(newTimeout); log.Info("Added new timeout: {0}", newTimeout); }
/// <summary> /// Gets all timeouts that are due by now. Doesn't remove the timeouts or change them or anything, /// each individual timeout can be marked as processed by calling <see cref="DueTimeout.MarkAsProcessed"/> /// </summary> public IEnumerable <DueTimeout> GetDueTimeouts() { var result = collection.Find(Query.LTE(TimeProperty, RebusTimeMachine.Now())) .SetSortOrder(SortBy.Ascending(TimeProperty)); return(result .Select(r => new DueMongoTimeout(r[ReplyToProperty].AsString, r.Contains(CorrIdProperty) ? r[CorrIdProperty].AsString : "", r[TimeProperty].AsDateTime, r.Contains(SagaIdProperty) ? r[SagaIdProperty].AsGuid : Guid.Empty, r.Contains(DataProperty) ? r[DataProperty].AsString : "", collection, (ObjectId)r[IdProperty]))); }
public void ErrorTrackerRemovesAMessageWhichTimedOut() { //Arrange const string messageId = "testId"; var fakeTime = RebusTimeMachine.Now(); TimeMachine.FixTo(fakeTime); //Act errorTracker.TrackDeliveryFail(messageId, new Exception()); errorTracker.TrackDeliveryFail(messageId, new Exception()); TimeMachine.FixTo(fakeTime.Add(timeoutSpan)); errorTracker.CheckForMessageTimeout(); var errorText = errorTracker.GetErrorText(messageId); //Assert Assert.That(errorText, Is.Empty); }
/// <summary> /// Queries the underlying table and returns due timeouts, removing them at the same time /// </summary> public IEnumerable <DueTimeout> GetDueTimeouts() { var dueTimeouts = new List <DueTimeout>(); var connection = getConnection(); try { using (var command = connection.CreateCommand()) { const string sql = @" SELECT ""id"", ""time_to_return"", ""correlation_id"", ""saga_id"", ""reply_to"", ""custom_data"" FROM ""{0}"" WHERE ""time_to_return"" <= @current_time ORDER BY ""time_to_return"" ASC "; command.CommandText = string.Format(sql, timeoutsTableName); command.Parameters.AddWithValue("current_time", RebusTimeMachine.Now()); using (var reader = command.ExecuteReader()) { while (reader.Read()) { var sqlTimeout = DuePostgreSqlTimeout.Create(MarkAsProcessed, timeoutsTableName, reader); dueTimeouts.Add(sqlTimeout); } } } connection.Commit(); } finally { releaseConnection(connection); } return(dueTimeouts); }
public void GoesOnToNextSilencePeriodAfterTheFirstHasElapsed() { var now = DateTime.UtcNow; var ignorant = new Ignorant { SilencePeriods = new[] { TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(10) } }; RebusTimeMachine.FakeIt(now); var first = ignorant.IsToBeIgnored(new ApplicationException("hej")); RebusTimeMachine.FakeIt(now + TimeSpan.FromMinutes(1.1)); var second = ignorant.IsToBeIgnored(new ApplicationException("hej")); RebusTimeMachine.FakeIt(now + TimeSpan.FromMinutes(11.1)); var third = ignorant.IsToBeIgnored(new ApplicationException("hej")); RebusTimeMachine.FakeIt(now + TimeSpan.FromMinutes(11.2)); var fourth = ignorant.IsToBeIgnored(new ApplicationException("hej")); RebusTimeMachine.FakeIt(now + TimeSpan.FromMinutes(21.2)); var fifth = ignorant.IsToBeIgnored(new ApplicationException("hej")); RebusTimeMachine.FakeIt(now + TimeSpan.FromMinutes(21.3)); var sixth = ignorant.IsToBeIgnored(new ApplicationException("hej")); Assert.That(first, Is.True); Assert.That(second, Is.False); Assert.That(third, Is.True); Assert.That(fourth, Is.False); Assert.That(fifth, Is.True); Assert.That(sixth, Is.False); }
/// <summary> /// Queries the underlying table and returns due timeouts, removing them at the same time /// </summary> public DueTimeoutsResult GetDueTimeouts() { var dueTimeouts = new List <DueTimeout>(); IDbConnection connection = null; IDbTransaction transaction = null; try { connection = factory.OpenConnection(); transaction = connection.BeginTransaction(); using (var command = connection.CreateCommand()) { command.Transaction = transaction; command.CommandText = FormatGetTimeoutsDueQuery(dialect, timeoutsTableName, batchSize); command.AddParameter("current_time", RebusTimeMachine.Now()); using (var reader = command.ExecuteReader()) { while (reader.Read()) { var sqlTimeout = DueAdoNetTimeout.Create(connection, timeoutsTableName, reader); dueTimeouts.Add(sqlTimeout); } } } } catch (Exception ex) { log.Error("GetDueTimeout produced an exception: {0}", ex); SafeDispose(transaction, "Disposing the transaction after exception produced other exception."); SafeDispose(connection, "Disposing the connection after exception produced other exception"); } return(new DueTimeoutsResult(dueTimeouts, () => CommitAndClose(connection, transaction))); }
public async Task TimeoutsAreNotReturnedUntilTheyAreActuallyDue() { var theFuture = DateTimeOffset.Now.AddMinutes(1); var evenFurtherIntoTheFuture = DateTimeOffset.Now.AddMinutes(8); await _timeoutManager.Defer(theFuture, HeadersWith("i know u"), EmptyBody()); await _timeoutManager.Defer(evenFurtherIntoTheFuture, HeadersWith("i know u too"), EmptyBody()); using (var result = await _timeoutManager.GetDueMessages()) { var dueTimeoutsNow = result.ToList(); Assert.That(dueTimeoutsNow.Count, Is.EqualTo(0)); } RebusTimeMachine.FakeIt(theFuture); using (var result = await _timeoutManager.GetDueMessages()) { var dueTimeoutsInTheFuture = result.ToList(); Assert.That(dueTimeoutsInTheFuture.Count, Is.EqualTo(1)); Assert.That(dueTimeoutsInTheFuture[0].Headers[Headers.MessageId], Is.EqualTo("i know u")); await dueTimeoutsInTheFuture[0].MarkAsCompleted(); } RebusTimeMachine.FakeIt(evenFurtherIntoTheFuture); using (var result = await _timeoutManager.GetDueMessages()) { var dueTimeoutsFurtherIntoInTheFuture = result.ToList(); Assert.That(dueTimeoutsFurtherIntoInTheFuture.Count, Is.EqualTo(1)); Assert.That(dueTimeoutsFurtherIntoInTheFuture[0].Headers[Headers.MessageId], Is.EqualTo("i know u too")); await dueTimeoutsFurtherIntoInTheFuture[0].MarkAsCompleted(); } }
/// <summary> /// Queries the underlying table and returns due timeouts, removing them at the same time /// </summary> public IEnumerable <DueTimeout> GetDueTimeouts() { using (var connection = new SqlConnection(connectionString)) { connection.Open(); var dueTimeouts = new List <DueTimeout>(); using (var command = connection.CreateCommand()) { command.CommandText = string.Format( @"select id, time_to_return, correlation_id, saga_id, reply_to, custom_data from [{0}] where time_to_return <= @current_time order by time_to_return asc", timeoutsTableName); command.Parameters.AddWithValue("current_time", RebusTimeMachine.Now()); using (var reader = command.ExecuteReader()) { while (reader.Read()) { var id = (long)reader["id"]; var correlationId = (string)reader["correlation_id"]; var sagaId = (Guid)reader["saga_id"]; var replyTo = (string)reader["reply_to"]; var timeToReturn = (DateTime)reader["time_to_return"]; var customData = (string)(reader["custom_data"] != DBNull.Value ? reader["custom_data"] : ""); var sqlTimeout = new DueSqlTimeout(id, replyTo, correlationId, timeToReturn, sagaId, customData, connectionString, timeoutsTableName); dueTimeouts.Add(sqlTimeout); } } } return(dueTimeouts); } }
public void ResetsWhenResetIsCalled() { var now = DateTime.UtcNow; var ignorant = new Ignorant { SilencePeriods = new[] { TimeSpan.FromMinutes(1) } }; RebusTimeMachine.FakeIt(now); var first = ignorant.IsToBeIgnored(new ApplicationException("hej")); RebusTimeMachine.FakeIt(now + TimeSpan.FromMinutes(0.9)); var second = ignorant.IsToBeIgnored(new ApplicationException("hej")); ignorant.Reset(); RebusTimeMachine.FakeIt(now + TimeSpan.FromMinutes(1.1)); var third = ignorant.IsToBeIgnored(new ApplicationException("hej")); Assert.That(first, Is.True); Assert.That(second, Is.True); Assert.That(third, Is.True); }
public void ErrorTrackerRemovesMultipleMessagesWhichTimedOut() { //Arrange const string messageId = "testId"; const string messageId2 = "testId2"; var fakeTime = RebusTimeMachine.Now(); TimeMachine.FixTo(fakeTime); //Act errorTracker.TrackDeliveryFail(messageId, new Exception()); TimeMachine.FixTo(fakeTime.Add(TimeSpan.FromMinutes(10))); errorTracker.TrackDeliveryFail(messageId2, new Exception()); TimeMachine.FixTo(fakeTime.AddDays(1).AddMinutes(10)); errorTracker.CheckForMessageTimeout(); var errorText1 = errorTracker.GetErrorText(messageId); var errorText2 = errorTracker.GetErrorText(messageId2); //Assert Assert.That(errorText1, Is.Empty); Assert.That(errorText2, Is.Empty); }