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(); }