public async Task NizzleName(int messageCount, bool useNewIndexScript, bool dropOldIndex)
{
if (useNewIndexScript)
{
SqlTestHelper.Execute(IndexCreationScriptToCheck);
SqlTestHelper.DropIndex(TableName, $"IDX_RECEIVE_{TableName}");
}
Console.WriteLine($"Sending {messageCount} messages...");
await Task.WhenAll(Enumerable.Range(0, messageCount)
.Select(i => _adapter.Bus.SendLocal($"THIS IS MESSAGE {i}")));
var counter = new SharedCounter(messageCount);
_adapter.Handle <string>(async message => counter.Decrement());
Console.WriteLine("Waiting for messages to be received...");
var stopwtach = Stopwatch.StartNew();
_adapter.Bus.Advanced.Workers.SetNumberOfWorkers(3);
counter.WaitForResetEvent(messageCount / 500 + 5);
var elapsedSeconds = stopwtach.Elapsed.TotalSeconds;
Console.WriteLine($"{messageCount} messages received in {elapsedSeconds:0.0} s - that's {messageCount / elapsedSeconds:0.0} msg/s");
}
public async Task ItWorks()
{
_activator.Register(() => new MySaga());
await _activator.Bus.SendLocal("hej");
await _activator.Bus.SendLocal("med");
await _activator.Bus.SendLocal("dig");
await Task.Delay(TimeSpan.FromSeconds(1));
var snapshots = SqlTestHelper
.Query <SagaSnapshot>(
$@"
SELECT
[Id],
[Revision]
FROM
[{TableName}]"
)
.OrderBy(s => s.Revision)
.ToList();
Assert.That(snapshots.Count, Is.EqualTo(3));
Assert.That(snapshots.Select(s => s.Revision), Is.EqualTo(new[] { 0, 1, 2 }), "Expected snapshots of revision 0, 1, and 2");
Assert.That(snapshots.GroupBy(s => s.Id).Count(), Is.EqualTo(1), "Expected three snapshots for the same saga ID");
}
public void CanGetActiveConnections()
{
var who = SqlTestHelper.ExecSpWho();
Console.WriteLine(string.Join(Environment.NewLine,
who.Select(d => string.Join(", ", d.Select(kvp => $"{kvp.Key} = {kvp.Value}")))));
}
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);
}
protected override void TearDown()
{
base.TearDown();
Console.WriteLine($@"The test has finished running - we have the following tables:
{string.Join(Environment.NewLine, SqlTestHelper.GetTableNames())}");
}
protected override void SetUp()
{
base.SetUp();
SqlTestHelper.DropAllTables();
Using(new DisposableCallback(SqlTestHelper.DropAllTables));
}
protected override void SetUp()
{
base.SetUp();
SqlTestHelper.DropTable("RebusOutbox");
_network = new InMemNetwork();
_subscriberStore = new InMemorySubscriberStore();
}
/// <summary>
/// See <see cref="TestingDistributedLockEngine.PerformCleanupForLockAbandonment"/>
/// </summary>
internal virtual void PerformCleanupForLockAbandonment()
{
// since connections are pooled, abandoning a SQL lock won't release the lock right away because the connection
// simply releases back to the pool but doesn't receive an sp_resetconnection until it is re-opened or the pool
// is cleared. Therefore, we clear the pool!
SqlTestHelper.ClearAllPools();
GC.Collect();
GC.WaitForPendingFinalizers();
}
protected override void SetUp()
{
SqlTestHelper.DropTable(_tableName);
_transport = new SqlServerTransport(new DbConnectionProvider(SqlTestHelper.ConnectionString), _tableName, QueueName);
_transport.EnsureTableIsCreated();
Using(_transport);
_transport.Initialize();
}
protected override void SetUp()
{
base.SetUp();
const string tableName = "Outbox";
SqlTestHelper.DropAllTables();
_storage = new SqlServerOutboxStorage(GetNewDbConnection, new TableName("dbo", tableName));
_storage.Initialize();
}
private static IEnumerable <SagaSnapshot> QuerySagaSnaps()
{
return(SqlTestHelper
.Query <SagaSnapshot>(
$@"
SELECT
[Id],
[Revision]
FROM
[{TableName}]"
));
}
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();
}
public void CleanUp()
{
_disposables.ForEach(d => d.Dispose());
_disposables.Clear();
foreach (var table in _tablesToDrop)
{
SqlTestHelper.DropTable(table);
}
_tablesToDrop.Clear();
}
public void TestConnectionDoesNotLeak()
{
var applicationName = nameof(TestConnectionDoesNotLeak) + Guid.NewGuid();
var connectionString = new SqlConnectionStringBuilder(ConnectionStringProvider.ConnectionString)
{
ApplicationName = applicationName,
}
.ConnectionString;
using (ConnectionStringProvider.UseConnectionString(connectionString))
using (var engine = this.CreateEngine())
{
var @lock = engine.CreateLock(nameof(TestConnectionDoesNotLeak));
for (var i = 0; i < 30; ++i)
{
using (@lock.Acquire())
{
CountActiveSessions().ShouldEqual(1, this.GetType().Name);
}
// still alive due to pooling
CountActiveSessions().ShouldEqual(1, this.GetType().Name);
}
}
using (var connection = SqlHelpers.CreateConnection(connectionString))
{
SqlTestHelper.ClearPool(connection);
// checking immediately seems flaky; likely clear pool finishing
// doesn't guarantee that SQL will immediately reflect the clear
var maxWaitForPoolsToClear = TimeSpan.FromSeconds(5);
var stopwatch = Stopwatch.StartNew();
do
{
var activeCount = CountActiveSessions();
if (activeCount == 0)
{
return;
}
Thread.Sleep(25);
}while (stopwatch.Elapsed < maxWaitForPoolsToClear);
}
int CountActiveSessions()
{
using var connection = SqlHelpers.CreateConnection(ConnectionStringProvider.ConnectionString);
connection.Open();
using var command = connection.CreateCommand();
command.CommandText = $@"SELECT COUNT(*) FROM sys.dm_exec_sessions WHERE program_name = '{applicationName}'";
return((int)command.ExecuteScalar());
}
}
public static void AssemblyInit(TestContext context)
{
var sqlTestHelper = new SqlTestHelper();
sqlTestHelper.DropDatabase();
sqlTestHelper.CreateDatabase();
TestHelpers = new Dictionary <string, IAdoTestHelper>();
TestHelpers["Nkv.Tests.Sql.SqlTestHelper"] = sqlTestHelper;
Providers = new Dictionary <string, IAdoProvider>();
Providers["Nkv.Sql.SqlProvider"] = sqlTestHelper.ConnectionProvider;
}
protected override void SetUp()
{
SqlTestHelper.DropTable(_tableName);
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, consoleLoggerFactory);
_transport = new SqlServerTransport(connectionProvider, _tableName, QueueName, consoleLoggerFactory);
_transport.EnsureTableIsCreated();
Using(_transport);
_transport.Initialize();
}
protected override void SetUp()
{
var loggerFactory = new ConsoleLoggerFactory(false);
_connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, loggerFactory);
_dataTableName = TestConfig.GetName("sagas");
_indexTableName = TestConfig.GetName("sagaindex");
SqlTestHelper.DropTable(_indexTableName);
SqlTestHelper.DropTable(_dataTableName);
_storage = new SqlServerSagaStorage(_connectionProvider, _dataTableName, _indexTableName, loggerFactory);
}
protected override void SetUp()
{
var loggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, loggerFactory);
var dataTableName = TestConfig.QueueName("sagas");
var indexTableName = TestConfig.QueueName("sagaindex");
SqlTestHelper.DropTable(indexTableName);
SqlTestHelper.DropTable(dataTableName);
_storage = new SqlServerSagaStorage(connectionProvider, dataTableName, indexTableName, loggerFactory);
_storage.EnsureTablesAreCreated();
}
protected override void SetUp()
{
SqlTestHelper.DropTable(TableName);
_adapter = Using(new BuiltinHandlerActivator());
Configure.With(_adapter)
.Logging(l => l.ColoredConsole(LogLevel.Warn))
.Transport(t => t.UseSqlServer(SqlTestHelper.ConnectionString, TableName, QueueName))
.Options(o =>
{
o.SetNumberOfWorkers(0);
o.SetMaxParallelism(20);
})
.Start();
}
protected override void SetUp()
{
var loggerFactory = new ConsoleLoggerFactory(false);
_connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, loggerFactory);
var sagaTypeNamingStrategy = new LegacySagaTypeNamingStrategy();
var serializer = new DefaultSagaSerializer();
_dataTableName = TestConfig.GetName("sagas");
_indexTableName = TestConfig.GetName("sagaindex");
SqlTestHelper.DropTable(_indexTableName);
SqlTestHelper.DropTable(_dataTableName);
_storage = new SqlServerSagaStorage(_connectionProvider, _dataTableName, _indexTableName, loggerFactory, sagaTypeNamingStrategy, serializer);
}
protected override void SetUp()
{
SqlTestHelper.Execute($"alter database [{SqlTestHelper.DatabaseName}] set allow_snapshot_isolation on");
Using(new DisposableCallback(() => SqlTestHelper.Execute($"alter database [{SqlTestHelper.DatabaseName}] set allow_snapshot_isolation off")));
_queueName = TestConfig.GetName("test-queue");
SqlTestHelper.DropTable(_queueName);
var transport = GetTransport(SqlTestHelper.ConnectionString, IsolationLevel.ReadCommitted);
Using(transport);
transport.EnsureTableIsCreated();
}
protected override void SetUp()
{
SqlTestHelper.DropTable(TableName);
_activator = Using(new BuiltinHandlerActivator());
Configure.With(_activator)
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(), "auditing-buggerino"))
.Sagas(s => s.StoreInMemory())
.Options(o =>
{
o.EnableSagaAuditing().StoreInSqlServer(SqlTestHelper.ConnectionString, TableName);
o.SetMaxParallelism(1);
})
.Start();
}
protected override void SetUp()
{
SqlTestHelper.DropTable("Messages");
_activator = new BuiltinHandlerActivator();
Using(_activator);
_bus = Configure.With(_activator)
.Transport(t => t.UseSqlServer(SqlTestHelper.ConnectionString, "Messages", QueueName))
.Options(o =>
{
o.LogPipeline();
})
.Start();
}
protected override void SetUp()
{
SqlTestHelper.DropTable("Messages");
_activator = new BuiltinHandlerActivator();
Using(_activator);
_starter = Configure.With(_activator)
.Transport(t => t.UseSqlServer(new SqlServerTransportOptions(SqlTestHelper.ConnectionString), QueueName))
.Routing(r => r.TypeBased().Map <TimedMessage>(QueueName))
.Options(o =>
{
o.LogPipeline();
})
.Create();
}
protected override void SetUp()
{
SqlTestHelper.DropTable(_tableName);
var consoleLoggerFactory = new ConsoleLoggerFactory(false);
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, consoleLoggerFactory);
var asyncTaskFactory = new TplAsyncTaskFactory(consoleLoggerFactory);
_transport = new SqlServerTransport(connectionProvider, _tableName, QueueName, consoleLoggerFactory, asyncTaskFactory);
_transport.EnsureTableIsCreated();
Using(_transport);
_transport.Initialize();
_cancellationToken = new CancellationTokenSource().Token;
}
protected override void SetUp()
{
SqlTestHelper.DropTable("RebusMessages");
_handlerActivator = new BuiltinHandlerActivator();
_bus = Configure.With(_handlerActivator)
.Transport(x => x.UseSqlServer(ConnectionString, "RebusMessages", "test.input"))
.Sagas(x => x.StoreInSqlServer(ConnectionString, "Sagas", "SagaIndex"))
.Options(x =>
{
x.SetNumberOfWorkers(1);
x.SetMaxParallelism(1);
})
.Start();
Using(_bus);
}
public void TestIsolationLevelLeakage()
{
const string IsolationLevelQuery = @"
SELECT CASE transaction_isolation_level
WHEN 0 THEN 'Unspecified'
WHEN 1 THEN 'ReadUncommitted'
WHEN 2 THEN 'ReadCommitted'
WHEN 3 THEN 'RepeatableRead'
WHEN 4 THEN 'Serializable'
WHEN 5 THEN 'Snapshot' END AS isolationLevel
FROM sys.dm_exec_sessions
WHERE session_id = @@SPID";
var connectionString = new SqlConnectionStringBuilder(ConnectionStringProvider.ConnectionString)
{
ApplicationName = nameof(TestIsolationLevelLeakage),
// makes it easy to test for leaks since all connections are the same
MaxPoolSize = 1,
}
.ConnectionString;
using (var connection = SqlHelpers.CreateConnection(connectionString)) { SqlTestHelper.ClearPool(connection); }
using var engine = new TEngineFactory().Create <TransactionBasedConnectionStringProvider>();
var @lock = engine.CreateLock(nameof(TestIsolationLevelLeakage));
@lock.Acquire().Dispose();
using (var connection = SqlHelpers.CreateConnection(connectionString))
{
connection.Open();
using var command = connection.CreateCommand();
command.CommandText = IsolationLevelQuery;
command.ExecuteScalar().ShouldEqual(IsolationLevel.ReadCommitted.ToString());
}
@lock.AcquireAsync().Result.Dispose();
using (var connection = SqlHelpers.CreateConnection(connectionString))
{
connection.Open();
using var command = connection.CreateCommand();
command.CommandText = IsolationLevelQuery;
command.ExecuteScalar().ShouldEqual(IsolationLevel.ReadCommitted.ToString());
}
}
IBus CreateBus(
string queueName,
Action <BuiltinHandlerActivator> handlers = null,
Action <TypeBasedRouterConfigurationExtensions.TypeBasedRouterConfigurationBuilder> routing = null
)
{
Using(new DisposableCallback(() => SqlTestHelper.DropTable(queueName)));
var activator = Using(new BuiltinHandlerActivator());
handlers?.Invoke(activator);
Configure.With(activator)
.Transport(t => t.UseSqlServerInLeaseMode(new SqlServerLeaseTransportOptions(SqlTestHelper.ConnectionString), queueName))
.Routing(r => routing?.Invoke(r.TypeBased()))
.Start();
return(activator.Bus);
}
protected override void SetUp()
{
SqlTestHelper.DropTable("subscriptions");
var network = new InMemNetwork();
_publisher = GetEndpoint(network, "publisher", c =>
{
c.Subscriptions(s => s.StoreInSqlServer(SqlTestHelper.ConnectionString, "subscriptions"));
c.Routing(r => r.TypeBased());
});
_client1GotTheEvent = new ManualResetEvent(false);
_client1 = GetEndpoint(network, "client1", c =>
{
c.Routing(r => r.TypeBased().Map <SomeKindOfEvent>("publisher"));
});
_client1.Handle <SomeKindOfEvent>(async e => _client1GotTheEvent.Set());
}
protected override void SetUp()
{
// start clean
SqlTestHelper.DropAllTables();
// end clean
Using(new DisposableCallback(SqlTestHelper.DropAllTables));
var loggerFactory = new ListLoggerFactory();
var connectionProvider = new DbConnectionProvider(SqlTestHelper.ConnectionString, loggerFactory);
_subscriptionStorage = new SqlServerSubscriptionStorage(connectionProvider, "Subscriptions", isCentralized: true, loggerFactory);
_subscriptionStorage.EnsureTableIsCreated();
_subscriptionStorage.Initialize();
_subscriberTransport = Using(new SqlServerTransport(connectionProvider, "subscriber", loggerFactory, new TplAsyncTaskFactory(loggerFactory), new FakeRebusTime(), new SqlServerTransportOptions(connectionProvider)));
_subscriberTransport.EnsureTableIsCreated();
_subscriberTransport.Initialize();
}
