protected override void SetUp()
{
var logger = new ListLoggerFactory(detailed: true);
// start the external timeout manager
Configure.With(Using(new BuiltinHandlerActivator()))
.Logging(l => l.Use(logger))
.Transport(t => t.UseMsmq(_queueNameTimeoutManager))
.Start();
_gotTheMessage = new ManualResetEvent(false);
// start the client
var client = Using(new BuiltinHandlerActivator());
client.Handle<string>(async str => _gotTheMessage.Set());
Configure.With(client)
.Logging(l => l.Use(logger))
.Transport(t => t.UseMsmq(_queueName))
.Options(o => o.UseExternalTimeoutManager(_queueNameTimeoutManager))
.Start();
_bus = client.Bus;
}
protected override void SetUp()
{
_activator = Using(new BuiltinHandlerActivator());
_listLoggerFactory = new ListLoggerFactory();
_bus = Configure.With(_activator)
.Logging(l => l.Use(_listLoggerFactory))
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "uow"))
.Start();
}
protected override void SetUp()
{
_listLoggerFactory = new ListLoggerFactory();
_adapter = new BuiltinHandlerActivator();
_network = new InMemNetwork(outputEventsToConsole: true);
var bus = Configure.With(_adapter)
.Logging(l => l.Use(_listLoggerFactory))
.Transport(t => t.UseInMemoryTransport(_network, "test"))
.Options(o => o.SimpleRetryStrategy("error", 3))
.Start();
Using(bus);
}
protected override void SetUp()
{
var queueName = TestConfig.QueueName("connection_timeout");
_activator = new BuiltinHandlerActivator();
Using(_activator);
_loggerFactory = new ListLoggerFactory(outputToConsole: true);
Configure.With(_activator)
.Logging(l => l.Use(_loggerFactory))
.Transport(t => t.UseSqlServer(SqlTestHelper.ConnectionString, "Messages", queueName))
.Start();
}
protected override void SetUp()
{
_activator = Using(new BuiltinHandlerActivator());
_logs = new ListLoggerFactory(outputToConsole: true, detailed: true);
Configure.With(_activator)
.Logging(l => l.Use(_logs))
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "log-levels"))
.Options(o =>
{
o.SetNumberOfWorkers(1);
o.SetMaxParallelism(1);
})
.Start();
}
protected override void SetUp()
{
_activator = Using(new BuiltinHandlerActivator());
_logs = new ListLoggerFactory(outputToConsole: true, detailed: true);
Configure.With(_activator)
.Logging(l => l.Use(_logs))
.Transport(t => t.UseSqlServer(SqlTestHelper.ConnectionString, "messages", TestConfig.QueueName("log-levels")))
.Options(o =>
{
o.SetNumberOfWorkers(1);
o.SetMaxParallelism(1);
})
.Start();
}
public void LogsWithTheRightType()
{
// arrange
var hasListOfLogStatements = new ListLoggerFactory();
CirqusLoggerFactory.Current = hasListOfLogStatements;
var loggingClass = new LoggingClass();
// act
loggingClass.LogSomething();
// assert
var line = hasListOfLogStatements.LoggedLines.Single();
Assert.That(line.OwnerType, Is.EqualTo(typeof(LoggingClass)));
}
public void Logs_by_default_for_ignored_includes()
{
var loggerFactory = new ListLoggerFactory();
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkInMemoryDatabase()
.AddSingleton <ILoggerFactory>(loggerFactory)
.BuildServiceProvider();
using (var context = new WarningAsErrorContext(serviceProvider, defaultThrow: false))
{
var _ = context.WarningAsErrorEntities.Include(e => e.Nav).OrderBy(e => e.Id).Select(e => e.Id).ToList();
Assert.Contains(CoreStrings.LogIgnoredInclude.GenerateMessage("[e].Nav"), loggerFactory.Log.Select(l => l.Message));
}
}
protected override void SetUp()
{
var queueName = TestConfig.GetName("connection_timeout");
_activator = new BuiltinHandlerActivator();
Using(_activator);
_loggerFactory = new ListLoggerFactory(outputToConsole: true);
Configure.With(_activator)
.Logging(l => l.Use(_loggerFactory))
.Transport(t => t.UseSqlServer(new SqlServerTransportOptions(SqlTestHelper.ConnectionString), queueName))
.Options(o => o.SetNumberOfWorkers(0))
.Start();
}
protected override void SetUp()
{
_builtinHandlerActivator = Using(new BuiltinHandlerActivator());
_loggerFactory = new ListLoggerFactory(outputToConsole: true);
_bus = Configure.With(_builtinHandlerActivator)
.Logging(l => l.Use(_loggerFactory))
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "will_experience_conflicts"))
.Options(o =>
{
o.SetNumberOfWorkers(10);
o.SetMaxParallelism(10);
})
.Start();
}
protected override void SetUp()
{
_factory = new TFactory();
_activator = new BuiltinHandlerActivator();
Using(_activator);
_logger = new ListLoggerFactory(true);
_bus = Configure.With(_activator)
.Logging(l => l.Use(_logger))
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "saga_snapshots_integration_testerino"))
.Options(o => o.EnableSagaAuditing().Register(c => _factory.Create()))
.Start();
}
public async Task SaveChangesAsync_with_canceled_token()
{
var loggerFactory = new ListLoggerFactory();
var provider =
InMemoryTestHelpers.Instance.CreateServiceProvider(
new ServiceCollection().AddSingleton <ILoggerFactory>(loggerFactory));
using var context = new ButTheHedgehogContext(provider);
context.Products.Add(new Product());
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => context.SaveChangesAsync(new CancellationToken(canceled: true)));
Assert.Contains(CoreEventId.SaveChangesCanceled, loggerFactory.Log.Select(l => l.Id));
Assert.DoesNotContain(CoreEventId.SaveChangesFailed, loggerFactory.Log.Select(l => l.Id));
}
public async Task Logs_commands_without_parameter_values(
Delegate commandDelegate,
string diagnosticName,
bool async)
{
var options = CreateOptions();
var logFactory = new ListLoggerFactory();
var fakeConnection = new FakeRelationalConnection(options);
var relationalCommand = CreateRelationalCommand(
new DiagnosticsLogger <DbLoggerCategory.Database.Command>(
logFactory,
new FakeLoggingOptions(false),
new DiagnosticListener("Fake")),
commandText: "Logged Command",
parameters: new[]
{ new TypeMappedRelationalParameter("FirstInvariant", "FirstParameter", new IntTypeMapping("int", DbType.Int32), false) });
var parameterValues = new Dictionary <string, object>
{
{ "FirstInvariant", 17 }
};
if (async)
{
await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues);
}
else
{
((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues);
}
Assert.Equal(2, logFactory.Log.Count);
Assert.Equal(LogLevel.Debug, logFactory.Log[0].Level);
Assert.Equal(LogLevel.Information, logFactory.Log[1].Level);
foreach (var(_, _, message, _, _) in logFactory.Log)
{
Assert.EndsWith(
"[Parameters=[FirstParameter='?' (DbType = Int32)], CommandType='0', CommandTimeout='30']" + _eol +
"Logged Command",
message);
}
}
public void Returns_same_provider_for_same_type_of_configured_extensions()
{
var loggerFactory = new ListLoggerFactory();
var config1 = CreateOptions <FakeDbContextOptionsExtension1>(loggerFactory);
var config2 = CreateOptions <FakeDbContextOptionsExtension1>(loggerFactory);
var cache = new ServiceProviderCache();
Assert.Same(cache.GetOrAdd(config1, true), cache.GetOrAdd(config2, true));
Assert.Single(loggerFactory.Log);
Assert.Equal(
CoreResources.LogServiceProviderCreated(new TestLogger <TestLoggingDefinitions>()).GenerateMessage(),
loggerFactory.Log[0].Message);
}
public void Returns_same_provider_for_same_type_of_configured_extensions()
{
var loggerFactory = new ListLoggerFactory();
var config1 = CreateOptions <FakeDbContextOptionsExtension1>(loggerFactory);
var config2 = CreateOptions <FakeDbContextOptionsExtension1>(loggerFactory);
var cache = new ServiceProviderCache();
Assert.Same(cache.GetOrAdd(config1, true), cache.GetOrAdd(config2, true));
Assert.Equal(1, loggerFactory.Log.Count);
Assert.Equal(
CoreStrings.LogServiceProviderCreated.GenerateMessage(),
loggerFactory.Log[0].Message);
}
protected override void SetUp()
{
MySqlTestHelper.DropAllTables();
var queueName = TestConfig.GetName("connection_timeout");
_activator = new BuiltinHandlerActivator();
Using(_activator);
_loggerFactory = new ListLoggerFactory(outputToConsole: true);
_starter = Configure.With(_activator)
.Logging(l => l.Use(_loggerFactory))
.Transport(t => t.UseMySql(new MySqlTransportOptions(MySqlTestHelper.ConnectionString), queueName))
.Create();
}
public void Batch_command_throws_on_delete_commands_with_circular_dependencies(bool sensitiveLogging)
{
var model = CreateCyclicFkWithTailModel();
var configuration = CreateContextServices(model);
var stateManager = configuration.GetRequiredService <IStateManager>();
var fakeEntry = stateManager.GetOrCreateEntry(
new FakeEntity {
Id = 1, RelatedId = 2
});
fakeEntry.SetEntityState(EntityState.Deleted);
var relatedFakeEntry = stateManager.GetOrCreateEntry(
new RelatedFakeEntity {
Id = 2, RelatedId = 1
});
relatedFakeEntry.SetEntityState(EntityState.Deleted);
var anotherFakeEntry = stateManager.GetOrCreateEntry(
new AnotherFakeEntity {
Id = 3, AnotherId = 2
});
anotherFakeEntry.SetEntityState(EntityState.Deleted);
var modelData = new UpdateAdapter(stateManager);
var expectedCycle = sensitiveLogging
? @"FakeEntity { 'Id': 1 } [Deleted] ForeignKey { 'RelatedId': 2 } <-
RelatedFakeEntity { 'Id': 2 } [Deleted] ForeignKey { 'RelatedId': 1 } <-
FakeEntity { 'Id': 1 } [Deleted]"
: @"FakeEntity [Deleted] ForeignKey { 'RelatedId' } <-
RelatedFakeEntity [Deleted] ForeignKey { 'RelatedId' } <-
FakeEntity [Deleted]"
+ CoreStrings.SensitiveDataDisabled;
Assert.Equal(
CoreStrings.CircularDependency(ListLoggerFactory.NormalizeLineEndings(expectedCycle)),
Assert.Throws <InvalidOperationException>(
() => CreateCommandBatchPreparer(updateAdapter: modelData, sensitiveLogging: sensitiveLogging).BatchCommands(
// Order is important for this test. Entry which is not part of cycle but tail should come first.
new[] { anotherFakeEntry, fakeEntry, relatedFakeEntry }, modelData).ToArray()).Message);
}
public DbContextOptions CreateOptions(
Action <ModelBuilder> onModelCreating = null, object additionalModelCacheKey = null, bool seed = true)
{
OnModelCreatingAction = onModelCreating;
AdditionalModelCacheKey = additionalModelCacheKey;
var options = CreateOptions(TestStore);
TestStore.Initialize(ServiceProvider, () => new EmbeddedTransportationContext(options), c =>
{
if (seed)
{
((TransportationContext)c).Seed();
}
});
ListLoggerFactory.Clear();
return(options);
}
public void VerifyOutputWhenLoggingAnError()
{
var list = new List<string>();
var factory = new ListLoggerFactory(list);
var logger = factory.GetCurrentClassLogger();
logger.Error(new OmgWtfException("omgwtf!!!"), "Unhandled system exception");
Console.WriteLine(@"Logger got the following line(s):
{0}
", string.Join(Environment.NewLine, list));
var loggedLine = list.Single();
loggedLine.ShouldContain("ERROR: Unhandled system exception");
loggedLine.ShouldContain(typeof(OmgWtfException).Name);
}
protected void ConfigureBus(Action <RebusConfigurer> configure)
{
Activator = new BuiltinHandlerActivator();
Network = new InMemNetwork();
LoggerFactory = new ListLoggerFactory(outputToConsole: true);
Using(Activator);
var rebusConfigurer = Configure.With(Activator)
.Logging(l => l.Use(LoggerFactory))
.Transport(t => t.UseInMemoryTransport(Network, "event-test"));
configure(rebusConfigurer);
rebusConfigurer
.Options(o => o.LogPipeline(true))
.Start();
}
protected override void SetUp()
{
// start clean
MySqlTestHelper.DropAllTables();
// end clean
Using(new DisposableCallback(MySqlTestHelper.DropAllTables));
var loggerFactory = new ListLoggerFactory();
var connectionProvider = new DbConnectionProvider(MySqlTestHelper.ConnectionString, loggerFactory);
_subscriptionStorage = new MySqlSubscriptionStorage(connectionProvider, "Subscriptions", isCentralized: true, loggerFactory);
_subscriptionStorage.EnsureTableIsCreated();
_subscriberTransport = Using(new MySqlTransport(connectionProvider, "subscriber", loggerFactory, new TplAsyncTaskFactory(loggerFactory), new FakeRebusTime(), new MySqlTransportOptions(connectionProvider)));
_subscriberTransport.EnsureTableIsCreated();
_subscriberTransport.Initialize();
}
protected TestModelBuilder(TestHelpers testHelpers)
{
var options = new LoggingOptions();
options.Initialize(new DbContextOptionsBuilder().EnableSensitiveDataLogging(false).Options);
ValidationLoggerFactory = new ListLoggerFactory(l => l == DbLoggerCategory.Model.Validation.Name);
var validationLogger = new DiagnosticsLogger <DbLoggerCategory.Model.Validation>(
ValidationLoggerFactory,
options,
new DiagnosticListener("Fake"));
ModelLoggerFactory = new ListLoggerFactory(l => l == DbLoggerCategory.Model.Name);
var modelLogger = new DiagnosticsLogger <DbLoggerCategory.Model>(
ModelLoggerFactory,
options,
new DiagnosticListener("Fake"));
ModelBuilder = testHelpers.CreateConventionBuilder(modelLogger, validationLogger);
}
public void VerifyOutputWhenLoggingAnError()
{
var list = new List <string>();
var factory = new ListLoggerFactory(list);
var logger = factory.GetCurrentClassLogger();
logger.Error(new OmgWtfException("omgwtf!!!"), "Unhandled system exception");
Console.WriteLine(@"Logger got the following line(s):
{0}
", string.Join(Environment.NewLine, list));
var loggedLine = list.Single();
loggedLine.ShouldContain("ERROR: Unhandled system exception");
loggedLine.ShouldContain(typeof(OmgWtfException).Name);
}
public async Task VerifyThatInitializationOnlyOccursOnce()
{
var database = MongoTestHelper.GetMongoDatabase();
var loggerFactory = new ListLoggerFactory(outputToConsole: true);
var storage = new MongoDbSagaStorage(database, loggerFactory);
storage.Initialize();
await storage.Insert(new SomeSagaData { Id = Guid.NewGuid() }, Enumerable.Empty <ISagaCorrelationProperty>());
await storage.Insert(new SomeSagaData { Id = Guid.NewGuid() }, Enumerable.Empty <ISagaCorrelationProperty>());
await storage.Insert(new SomeSagaData { Id = Guid.NewGuid() }, Enumerable.Empty <ISagaCorrelationProperty>());
var numberOfInitializations = loggerFactory
.Count(line => line.Text.Contains("Initializing index for saga data"));
Assert.That(numberOfInitializations, Is.EqualTo(1),
"Only expected the collection's indexes to be initialized once!");
}
public void OutputsSagaDataSnapshotsToLog()
{
var logger = new ListLoggerFactory(true);
RunTheTest(logger);
var lines = logger
.Where(line => line.Text.Contains("\"CorrelationId\":\"hej\""))
.ToList();
Assert.That(lines.Count, Is.EqualTo(3));
Console.WriteLine($@"
Here we have the logged saga data snapshots:
{string.Join(Environment.NewLine, lines)}
");
}
public void Lazy_load_with_disposed_context_can_be_configured_to_log_at_debug_level()
{
var loggerFactory = new ListLoggerFactory();
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkInMemoryDatabase()
.AddSingleton <ILoggerFactory>(loggerFactory)
.BuildServiceProvider(validateScopes: true);
using (var context = new WarningAsErrorContext(
serviceProvider,
defaultThrow: false,
toChangeLevel: (CoreEventId.LazyLoadOnDisposedContextWarning, LogLevel.Debug)))
{
context.Add(
new WarningAsErrorEntity {
Nav = new IncludedEntity()
});
context.SaveChanges();
}
WarningAsErrorEntity entity;
using (var context = new WarningAsErrorContext(
serviceProvider,
defaultThrow: false,
toChangeLevel: (CoreEventId.LazyLoadOnDisposedContextWarning, LogLevel.Debug)))
{
entity = context.WarningAsErrorEntities.OrderBy(e => e.Id).First();
}
Assert.Null(entity.Nav);
var log = loggerFactory.Log.Single(
l => l.Message
== CoreResources
.LogLazyLoadOnDisposedContext(new TestLogger <InMemoryLoggingDefinitions>())
.GenerateMessage("WarningAsErrorEntity", "Nav"));
Assert.Equal(LogLevel.Debug, log.Level);
}
protected override void SetUp()
{
_activator = new BuiltinHandlerActivator();
Using(_activator);
_listLoggerFactory = new ListLoggerFactory(outputToConsole: false);
Configure.With(_activator)
.Logging(l => l.Use(_listLoggerFactory))
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "scaling-test"))
.Options(o =>
{
o.EnableAutoScaling(maxNumberOfWorkers: 10, adjustmentIntervalSeconds: 1);
})
.Start();
_workerCounter = new WorkerCounter(_activator.Bus);
Using(_workerCounter);
}
protected override void SetUp()
{
_activator = Using(new BuiltinHandlerActivator());
_listLoggerFactory = new ListLoggerFactory();
Configure.With(_activator)
.Logging(l => l.Use(_listLoggerFactory))
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "customize exceptions"))
.Routing(r =>
{
r.ForwardOnException<ApplicationException>("error", LogLevel.Error);
r.ForwardOnException<CustomException>("error", LogLevel.Error, e =>
{
Console.WriteLine("Checking {0}", e);
return e.ErrorCode == SecretErrorCode;
});
})
.Options(o => o.LogPipeline(verbose: true))
.Start();
}
protected override void SetUp()
{
_loggerFactory = new ListLoggerFactory();
_activator = new BuiltinHandlerActivator();
Using(_activator);
Configure.With(_activator)
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "somequeue"))
.Logging(l => l.Use(_loggerFactory))
.Options(o =>
{
o.Decorate <ITransport>(c =>
{
var transport = c.Get <ITransport>();
_failToggle = new FailToggleTransport(transport);
return(_failToggle);
});
})
.Start();
}
protected override void SetUp()
{
var network = new InMemNetwork();
_events = new ConcurrentQueue <string>();
_uowActivator = new BuiltinHandlerActivator();
Using(_uowActivator);
_loggerFactory = new ListLoggerFactory(outputToConsole: true);
Configure.With(_uowActivator)
.Logging(l => l.Use(_loggerFactory))
.Transport(t => t.UseInMemoryTransport(network, UowQueueName))
.Options(o =>
{
o.EnableUnitOfWork(async c => _events, commitAction: async(c, e) => {});
o.SimpleRetryStrategy(maxDeliveryAttempts: 1);
})
.Start();
}
public void GetDbTransaction_returns_the_DbTransaction()
{
var dbConnection = new FakeDbConnection(ConnectionString);
var dbTransaction = new FakeDbTransaction(dbConnection);
var connection = new FakeRelationalConnection(
CreateOptions((FakeRelationalOptionsExtension) new FakeRelationalOptionsExtension().WithConnection(dbConnection)));
var loggerFactory = new ListLoggerFactory();
var transaction = new RelationalTransaction(
connection,
dbTransaction,
new DiagnosticsLogger <DbLoggerCategory.Database.Transaction>(
loggerFactory,
new LoggingOptions(),
new DiagnosticListener("Fake")),
false);
Assert.Equal(dbTransaction, transaction.GetDbTransaction());
}
private void FilterTest(Func <string, bool> filter, params string[] expected)
{
var loggerFactory = new ListLoggerFactory(Log, filter);
var dbLogger = new DiagnosticsLogger <DbLoggerCategory.Database>(loggerFactory, new LoggingOptions(), new DiagnosticListener("Fake"));
var sqlLogger = new DiagnosticsLogger <DbLoggerCategory.Database.Command>(loggerFactory, new LoggingOptions(), new DiagnosticListener("Fake"));
var queryLogger = new DiagnosticsLogger <DbLoggerCategory.Query>(loggerFactory, new LoggingOptions(), new DiagnosticListener("Fake"));
var randomLogger = loggerFactory.CreateLogger("Random");
dbLogger.Logger.LogInformation(1, "DB1");
sqlLogger.Logger.LogInformation(2, "SQL1");
queryLogger.Logger.LogInformation(3, "Query1");
randomLogger.LogInformation(4, "Random1");
dbLogger.Logger.LogInformation(1, "DB2");
sqlLogger.Logger.LogInformation(2, "SQL2");
queryLogger.Logger.LogInformation(3, "Query2");
randomLogger.LogInformation(4, "Random2");
Assert.Equal(expected, Log.Select(l => l.Message));
}
protected override void SetUp()
{
_activator = Using(new BuiltinHandlerActivator());
_listLoggerFactory = new ListLoggerFactory();
Configure.With(_activator)
.Logging(l => l.Use(_listLoggerFactory))
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "customize exceptions"))
.Routing(r =>
{
r.ForwardOnException <ApplicationException>("error", LogLevel.Error);
r.ForwardOnException <CustomException>("error", LogLevel.Error, e =>
{
Console.WriteLine("Checking {0}", e);
return(e.ErrorCode == SecretErrorCode);
});
})
.Options(o => o.LogPipeline(verbose: true))
.Start();
}
protected override void SetUp()
{
_loggerFactory = new ListLoggerFactory();
_activator = new BuiltinHandlerActivator();
Using(_activator);
Configure.With(_activator)
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "somequeue"))
.Logging(l => l.Use(_loggerFactory))
.Options(o =>
{
o.Decorate<ITransport>(c =>
{
var transport = c.Get<ITransport>();
_failToggle = new FailToggleTransport(transport);
return _failToggle;
});
})
.Start();
}
public async Task VerifyIt()
{
var gotTheMessage = new ManualResetEvent(initialState: false);
var services = new ServiceCollection();
var loggerFactory = new ListLoggerFactory(outputToConsole: true, detailed: true);
services.AddSingleton(gotTheMessage);
services.AddScoped <SomethingDisposable>();
services.AddRebusHandler <StringHandler>();
services.AddRebus(configure => configure
.Logging(l => l.Use(loggerFactory))
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "who cares"))
.Options(o => o.Decorate <IPipeline>(c =>
{
var pipeline = c.Get <IPipeline>();
return(new PipelineStepInjector(pipeline)
.OnReceive(new MyScopeStep(), PipelineRelativePosition.Before, typeof(DeserializeIncomingMessageStep)));
})));
var provider = Using(services.BuildServiceProvider());
provider.UseRebus();
await provider.GetRequiredService <IBus>().SendLocal("hej søde ven!");
gotTheMessage.WaitOrDie(
timeout: TimeSpan.FromSeconds(3),
errorMessage: "Message was not received within 3 s timeout, which means that an exception must have occurred somewhere");
await Task.Delay(TimeSpan.FromSeconds(2));
var foundWarningOrError = loggerFactory.Any(log => log.Level > LogLevel.Info);
Assert.That(foundWarningOrError, Is.False,
"The log contained one or more warnings/errors, which is an indication that something went wrong when dispatching the message");
}
public async Task ThisIsHowItIsDone()
{
var loggerFactory = new ListLoggerFactory(outputToConsole: true);
var network = new InMemNetwork();
var handlerActivator = Using(new BuiltinHandlerActivator());
handlerActivator.Handle <ProcessThisThingRequest>((bus, request) => bus.Reply(new ProcessThisThingReply(request.Thing, request.SagaId)));
Configure.With(handlerActivator)
.Logging(l => l.None())
.Transport(t => t.UseInMemoryTransport(network, "processor"))
.Start();
var sagaActivator = Using(new BuiltinHandlerActivator());
sagaActivator.Register((bus, context) => new TypicalContendedSagaExample(bus));
Configure.With(sagaActivator)
.Logging(l => l.Use(loggerFactory))
.Transport(t => t.UseInMemoryTransport(network, "lock-test"))
.Sagas(s =>
{
s.StoreInMemory();
s.EnforceExclusiveAccess(new CustomLocker());
})
.Routing(t => t.TypeBased().Map <ProcessThisThingRequest>("processor"))
.Options(o =>
{
o.SetMaxParallelism(100);
o.SetNumberOfWorkers(10);
})
.Start();
await sagaActivator.Bus.SendLocal(new ProcessTheseThings(Enumerable.Range(0, 10).Select(no => $"THING-{no}")));
await Task.Delay(TimeSpan.FromSeconds(3));
Assert.That(loggerFactory.Count(l => l.Level >= LogLevel.Warn), Is.EqualTo(0), "Didn't expect any logging with level WARNING or above");
}
public void CheckThatItDoesNotEnlistInOtherBusTransactionCotnext()
{
_listLoggerFactory = new ListLoggerFactory(true);
_firstNetwork = new InMemNetwork();
_secondNetwork = new InMemNetwork();
_activator1 = StartBus(_firstNetwork, "endpoint");
_activator2 = StartBus(_secondNetwork, "proper-destination");
// prepare dead-end queue on first network
_firstNetwork.CreateQueue("dead-end");
// register handler on first network's endpoint that forwards to 'proper-destination' by using the other bus
_activator1.Register(() =>
{
var otherBus = _activator2.Bus;
var handler = new HandlerThatUsesAnotherBus(otherBus);
return(handler);
});
// prepare handler on the bus on the other network so we can receive the message
var gotTheMessage = new ManualResetEvent(false);
_activator2.Handle <string>(async str => gotTheMessage.Set());
_activator1.Bus.Advanced.Workers.SetNumberOfWorkers(1);
_activator2.Bus.Advanced.Workers.SetNumberOfWorkers(1);
_activator1.Bus.SendLocal("hej med dig min ven!!").Wait();
gotTheMessage.WaitOrDie(TimeSpan.FromSeconds(3), @"Looks like we never got the message.
If everything was working properly, the forwarded message would have
been sent in its own transaction context, thus sent&committed
immediately when calling bus.....Forward");
}
public void Reports_debug_info_for_different_ILoggerFactory_instances()
{
var config1 = CreateOptions <CoreOptionsExtension>(new ListLoggerFactory());
var loggerFactory = new ListLoggerFactory();
var config2 = CreateOptions <CoreOptionsExtension>(loggerFactory);
var cache = new ServiceProviderCache();
var first = cache.GetOrAdd(config1, true);
var second = cache.GetOrAdd(config2, true);
Assert.NotSame(first, second);
Assert.Equal(1, loggerFactory.Log.Count);
Assert.Equal(
CoreStrings.LogServiceProviderDebugInfo.GenerateMessage(
CoreStrings.ServiceProviderConfigChanged("Core:UseLoggerFactory")),
loggerFactory.Log[0].Message);
}
public void Lazy_loading_is_logged_only_when_actually_loading()
{
var loggerFactory = new ListLoggerFactory();
var serviceProvider = new ServiceCollection()
.AddEntityFrameworkInMemoryDatabase()
.AddSingleton <ILoggerFactory>(loggerFactory)
.BuildServiceProvider(validateScopes: true);
using (var context = new WarningAsErrorContext(serviceProvider, defaultThrow: false))
{
context.Add(
new WarningAsErrorEntity {
Nav = new IncludedEntity()
});
context.SaveChanges();
}
using (var context = new WarningAsErrorContext(serviceProvider, defaultThrow: false))
{
var entity = context.WarningAsErrorEntities.OrderBy(e => e.Id).First();
loggerFactory.Clear();
Assert.NotNull(entity.Nav);
Assert.Contains(
CoreResources.LogNavigationLazyLoading(new TestLogger <InMemoryLoggingDefinitions>())
.GenerateMessage("WarningAsErrorEntity", "Nav"),
loggerFactory.Log.Select(l => l.Message));
loggerFactory.Clear();
Assert.NotNull(entity.Nav);
Assert.DoesNotContain(
CoreResources.LogNavigationLazyLoading(new TestLogger <InMemoryLoggingDefinitions>())
.GenerateMessage("WarningAsErrorEntity", "Nav"),
loggerFactory.Log.Select(l => l.Message));
}
}
protected override void SetUp()
{
_loggerFactory = new ListLoggerFactory(detailed: true, outputToConsole: true);
_router = new TypeBasedRouter(_loggerFactory);
}
protected override void SetUp()
{
_listLoggerFactory = new ListLoggerFactory();
}
protected override void SetUp()
{
_listLoggerFactory = new ListLoggerFactory();
RebusLoggerFactory.Current = _listLoggerFactory;
}
