public TestHelper()
: base(typeof(TestHelper).Assembly)
{
var httpContext = new DefaultHttpContext();
httpContext.Connection.RemoteIpAddress = IPAddress.Parse("127.0.0.1");
_httpContextAccessor = Mock.Of <IHttpContextAccessor>(x => x.HttpContext == httpContext);
_ipResolver = new AspNetCoreIpResolver(_httpContextAccessor);
string contentRoot = Assembly.GetExecutingAssembly().GetRootDirectorySafe();
// The mock for IWebHostEnvironment has caused a good few issues.
// We can UseContentRoot, UseWebRoot etc on the host builder instead.
// possibly going down rabbit holes though as would need to cleanup all usages of
// GetHostingEnvironment & GetWebHostEnvironment.
var hostEnvironment = new Mock <IWebHostEnvironment>();
// This must be the assembly name for the WebApplicationFactory to work.
hostEnvironment.Setup(x => x.ApplicationName).Returns(GetType().Assembly.GetName().Name);
hostEnvironment.Setup(x => x.ContentRootPath).Returns(() => contentRoot);
hostEnvironment.Setup(x => x.ContentRootFileProvider).Returns(() => new PhysicalFileProvider(contentRoot));
hostEnvironment.Setup(x => x.WebRootPath).Returns(() => WorkingDirectory);
hostEnvironment.Setup(x => x.WebRootFileProvider).Returns(() => new PhysicalFileProvider(WorkingDirectory));
hostEnvironment.Setup(x => x.EnvironmentName).Returns("Tests");
// We also need to expose it as the obsolete interface since netcore's WebApplicationFactory casts it.
hostEnvironment.As <Microsoft.AspNetCore.Hosting.IHostingEnvironment>();
_hostEnvironment = hostEnvironment.Object;
_hostingLifetime = new AspNetCoreApplicationShutdownRegistry(Mock.Of <IHostApplicationLifetime>());
ConsoleLoggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
ProfilingLogger = new ProfilingLogger(ConsoleLoggerFactory.CreateLogger <ProfilingLogger>(), Profiler);
}
protected override void SetUp()
{
var loggerFactory = new ConsoleLoggerFactory(false);
_storage = new OracleDataBusStorage(OracleTestHelper.ConnectionHelper, tableName, loggerFactory, new FakeRebusTime());
_storage.EnsureTableIsCreated();
}
static SqlServerTransport GetTransport(TransportType transportType)
{
var rebusTime = new DefaultRebusTime();
var loggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, loggerFactory);
var asyncTaskFactory = new TplAsyncTaskFactory(loggerFactory);
var transport = transportType == TransportType.LeaseBased
? new SqlServerLeaseTransport(
connectionProvider,
QueueName,
loggerFactory,
asyncTaskFactory,
rebusTime,
TimeSpan.FromMinutes(1),
TimeSpan.FromSeconds(5),
() => "who cares",
new SqlServerLeaseTransportOptions(connectionProvider)
)
: new SqlServerTransport(
connectionProvider,
QueueName,
loggerFactory,
asyncTaskFactory,
rebusTime,
new SqlServerTransportOptions(connectionProvider)
);
transport.EnsureTableIsCreated();
transport.Initialize();
return(transport);
}
static void Main(string[] args)
{
ILoggerFactory loggerFactory = new ConsoleLoggerFactory();
using (CachingRepository <MessageTemplate> repository
= new CachingRepository <MessageTemplate>(
new Repository <MessageTemplate>(new MessageTemplatesContext())))
{
ITransmissionStrategy transmissionStrategy =
new SmsTransmissionStrategy(loggerFactory);
Messenger messenger = new Messenger(
loggerFactory,
repository,
transmissionStrategy);
IUser user = new User("Gen-Eric", "*****@*****.**", "+4522123631");
messenger.Send(new Message
{
Recipient = user,
MessageTemplateId = 1,
Parameters = new List <object> {
"Jesper", DateTime.Now
}
});
Console.ReadLine();
}
}
SqlServerTransport GetTransport(string connectionString, IsolationLevel isolationLevel)
{
var rebusTime = new DefaultRebusTime();
var rebusLoggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(connectionString, rebusLoggerFactory)
{
IsolationLevel = isolationLevel
};
var taskFactory = new TplAsyncTaskFactory(rebusLoggerFactory);
var transport = new SqlServerTransport(
connectionProvider: connectionProvider,
inputQueueName: _queueName,
rebusLoggerFactory: rebusLoggerFactory,
asyncTaskFactory: taskFactory,
rebusTime: rebusTime,
options: new SqlServerTransportOptions(connectionProvider)
);
transport.Initialize();
return(transport);
}
protected override void SetUp()
{
var connectionString = AsbTestConfig.ConnectionString;
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
using (var transport = new AzureServiceBusTransport(connectionString, QueueName, consoleLoggerFactory, asyncTaskFactory, new DefaultNameFormatter()))
{
transport.PurgeInputQueue();
}
_activator = new BuiltinHandlerActivator();
_busStarter = Configure.With(_activator)
.Transport(t => t.UseAzureServiceBus(connectionString, QueueName))
.Routing(r => r.TypeBased().Map <TimedMessage>(QueueName))
.Options(o =>
{
o.LogPipeline();
})
.Create();
_bus = _busStarter.Bus;
Using(_bus);
}
public async Task DeliversMessagesByVisibleTimeAndNotByInsertionTime()
{
var rebusTime = new DefaultRebusTime();
var loggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(MySqlTestHelper.ConnectionString, loggerFactory);
var asyncTaskFactory = new TplAsyncTaskFactory(loggerFactory);
var transport = new MySqlTransport(
connectionProvider,
QueueName,
loggerFactory,
asyncTaskFactory,
rebusTime,
new MySqlTransportOptions(connectionProvider));
transport.EnsureTableIsCreated();
transport.Initialize();
var now = DateTime.Now;
await PutInQueue(transport, GetTransportMessage("first message"));
await PutInQueue(transport, GetTransportMessage("second message", deferredUntilTime : now.AddMinutes(-1)));
await PutInQueue(transport, GetTransportMessage("third message", deferredUntilTime : now.AddMinutes(-2)));
var firstMessage = await ReceiveMessageBody(transport);
var secondMessage = await ReceiveMessageBody(transport);
var thirdMessage = await ReceiveMessageBody(transport);
// expect messages to be received in reverse order because of their visible times
Assert.That(firstMessage, Is.EqualTo("third message"));
Assert.That(secondMessage, Is.EqualTo("second message"));
Assert.That(thirdMessage, Is.EqualTo("first message"));
}
static MySqlSubscriptionStorage GetStorage(bool createCustomSchema)
{
MySqlTestHelper.DropTable("Subscriptions");
var loggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(MySqlTestHelper.ConnectionString, loggerFactory);
var storage = new MySqlSubscriptionStorage(connectionProvider, "Subscriptions", true, loggerFactory);
if (createCustomSchema)
{
var tableName = TableName.Parse("Subscriptions");
MySqlTestHelper.Execute($@"
CREATE TABLE {tableName.QualifiedName} (
`topic` VARCHAR(350) NOT NULL,
`address` VARCHAR(50) NOT NULL,
PRIMARY KEY (`topic`, `address`)
)");
}
else
{
storage.EnsureTableIsCreated();
}
return(storage);
}
public ITransport Create(string inputQueueAddress)
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
if (inputQueueAddress == null)
{
var transport = new AzureServiceBusTransport(ConnectionString, null, consoleLoggerFactory, asyncTaskFactory);
transport.Initialize();
return(transport);
}
return(_queuesToDelete.GetOrAdd(inputQueueAddress, () =>
{
var transport = new BasicAzureServiceBusTransport(ConnectionString, inputQueueAddress, consoleLoggerFactory, asyncTaskFactory);
transport.PurgeInputQueue();
transport.Initialize();
return transport;
}));
}
static SqlServerSubscriptionStorage GetStorage(bool createCustomSchema)
{
SqlTestHelper.DropTable("Subscriptions");
var loggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, loggerFactory);
var storage = new SqlServerSubscriptionStorage(connectionProvider, "Subscriptions", true, loggerFactory);
if (createCustomSchema)
{
var tableName = TableName.Parse("Subscriptions");
SqlTestHelper.Execute($@"
CREATE TABLE {tableName.QualifiedName} (
[topic] [nvarchar](350) NOT NULL,
[address] [nvarchar](50) NOT NULL,
CONSTRAINT [PK_{tableName.Schema}_{tableName.Name}] PRIMARY KEY CLUSTERED
(
[topic] ASC,
[address] ASC
)
)
");
}
else
{
storage.EnsureTableIsCreated();
}
storage.Initialize();
return(storage);
}
public async Task Dispose_WhenAutoDeleteQueueEnabled_DropsInputQueue()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, consoleLoggerFactory);
const string queueName = "input";
var options = new SqlServerTransportOptions(SqlTestHelper.ConnectionString);
var activator = Using(new BuiltinHandlerActivator());
Configure.With(activator)
.Logging(l => l.Use(consoleLoggerFactory))
.Transport(t => t.UseSqlServer(options, queueName).SetAutoDeleteQueue(true))
.Start();
using (var connection = await connectionProvider.GetConnection())
{
Assert.That(connection.GetTableNames().Contains(TableName.Parse(queueName)), Is.True);
}
CleanUpDisposables();
using (var connection = await connectionProvider.GetConnection())
{
Assert.That(connection.GetTableNames().Contains(TableName.Parse(queueName)), Is.False);
}
}
public static AmazonSqsTransport CreateTransport(string inputQueueAddress, TimeSpan peeklockDuration, AmazonSQSTransportOptions options = null)
{
var connectionInfo = ConnectionInfo;
var amazonSqsConfig = new AmazonSQSConfig {
RegionEndpoint = connectionInfo.RegionEndpoint
};
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var credentials = new BasicAWSCredentials(connectionInfo.AccessKeyId, connectionInfo.SecretAccessKey);
options ??= new AmazonSQSTransportOptions();
options.ClientFactory = () => new AmazonSQSClient(credentials, amazonSqsConfig);
var transport = new AmazonSqsTransport(
inputQueueAddress,
consoleLoggerFactory,
new TplAsyncTaskFactory(consoleLoggerFactory),
options,
new DefaultRebusTime()
);
transport.Initialize(peeklockDuration);
transport.Purge();
return(transport);
}
static Logger()
{
#if DEBUG
Factory = new ConsoleLoggerFactory();
#else
Factory = new SilentLoggerFactory();
#endif
}
public IDataBusStorage Create()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var storage = new OracleDataBusStorage(OracleTestHelper.ConnectionHelper, "databus", consoleLoggerFactory, _fakeRebusTime);
storage.EnsureTableIsCreated();
return(storage);
}
static void PurgeQueue(string queueName)
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
new AmazonSqsTransport(queueName, AmazonSqsTransportFactory.ConnectionInfo.AccessKeyId, AmazonSqsTransportFactory.ConnectionInfo.SecretAccessKey,
RegionEndpoint.GetBySystemName(AmazonSqsTransportFactory.ConnectionInfo.RegionEndpoint), consoleLoggerFactory,
new TplAsyncTaskFactory(consoleLoggerFactory)).Purge();
}
public IDataBusStorage Create()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(MySqlTestHelper.ConnectionString, consoleLoggerFactory);
var mySqlDataBusStorage = new MySqlDataBusStorage(connectionProvider, "databus", true, consoleLoggerFactory, _fakeRebusTime, 240);
mySqlDataBusStorage.Initialize();
return(mySqlDataBusStorage);
}
public static void PurgeQueue(string queueName)
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var transport = ActiveMqTransportFactory.CreateTransport(queueName);
transport.Delete().RunSync();
transport.CreateQueue();
}
static void PurgeQueue(string queueName)
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
var connectionString = StandardAzureServiceBusTransportFactory.ConnectionString;
new AzureServiceBusTransport(connectionString, queueName, consoleLoggerFactory, asyncTaskFactory)
.PurgeInputQueue();
}
public void CreateSqlServerLoggerTest()
{
var logger = new SeriLogger(new Mock <ApplicationLoggerSettings>().Object);
var config = logger.ConfigureSerilog();
var result = ConsoleLoggerFactory.CreateLogger(config);
Assert.NotNull(result);
}
public IDataBusStorage Create()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, consoleLoggerFactory);
var sqlServerDataBusStorage = new SqlServerDataBusStorage(connectionProvider, "databus", true, consoleLoggerFactory, 240);
sqlServerDataBusStorage.Initialize();
return(sqlServerDataBusStorage);
}
public ITimeoutManager Create()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(true);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, consoleLoggerFactory);
var timeoutManager = new SqlServerTimeoutManager(connectionProvider, TableName, consoleLoggerFactory);
timeoutManager.EnsureTableIsCreated();
return(timeoutManager);
}
public ISubscriptionStorage Create()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(true);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, consoleLoggerFactory);
var storage = new SqlServerSubscriptionStorage(connectionProvider, TableName, true, consoleLoggerFactory);
storage.EnsureTableIsCreated();
return(storage);
}
public TestIdempotentMessageStorage()
{
MySqlTestHelper.DropTableIfExists(_tableName).Wait();
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var connectionHelper = new MySqlConnectionHelper(MySqlTestHelper.ConnectionString);
_messageStorage = new MySqlMessageStorage(connectionHelper, _tableName, consoleLoggerFactory);
_messageStorage.EnsureTablesAreCreated().Wait();
Using(_messageStorage);
}
public ISagaStorage GetSagaStorage()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(true);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, consoleLoggerFactory);
var storage = new SqlServerSagaStorage(connectionProvider, DataTableName, IndexTableName, consoleLoggerFactory);
storage.EnsureTablesAreCreated();
return(storage);
}
public ConsoleLogger(Type type, LoggingColors loggingColors, ConsoleLoggerFactory factory, bool showTimestamps)
{
_type = type;
_loggingColors = loggingColors;
_factory = factory;
_logLineFormatString = showTimestamps
? "[{2}] {0} {1} ({3}): {4}"
: "[{2}] {1} ({3}): {4}";
}
public void LoggerFactory()
{
//---------------Set up test pack-------------------
IHabaneroLoggerFactory loggerFactory = new ConsoleLoggerFactory();
//---------------Execute Test ----------------------
GlobalRegistry.LoggerFactory = loggerFactory;
//---------------Test Result -----------------------
Assert.AreSame(loggerFactory, GlobalRegistry.LoggerFactory);
}
protected override void SetUp()
{
var loggerFactory = new ConsoleLoggerFactory(false);
errorQueueTransport = new AzureServiceBusTransport(AsbTestConfig.ConnectionString, "error", loggerFactory, new TplAsyncTaskFactory(loggerFactory), new DefaultNameFormatter());
Using(errorQueueTransport);
errorQueueTransport.Initialize();
errorQueueTransport.PurgeInputQueue();
}
public ISagaSnapshotStorage Create()
{
var consoleLoggerFactory = new ConsoleLoggerFactory(true);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, consoleLoggerFactory);
var snapperino = new SqlServerSagaSnapshotStorage(connectionProvider, TableName, consoleLoggerFactory);
snapperino.EnsureTableIsCreated();
return(snapperino);
}
static void PurgeQueue(string queueName)
{
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
var connectionString = AsbTestConfig.ConnectionString;
using (var transport = new AzureServiceBusTransport(connectionString, queueName, consoleLoggerFactory, asyncTaskFactory, new DefaultNameFormatter()))
{
transport.PurgeInputQueue();
}
}
protected override void SetUp()
{
var loggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, loggerFactory);
var tableName = TestConfig.QueueName("data");
SqlTestHelper.DropTable(tableName);
_storage = new SqlServerDataBusStorage(connectionProvider, tableName, true, loggerFactory);
_storage.Initialize();
}
