public void DatabaseObjectCleanUpTest()
{
var mapper = new ModelToTableMapper <DatabaseObjectAutoCleanUpAfter2InsertsTestSqlServerModel>();
mapper.AddMapping(c => c.Name, "First Name").AddMapping(c => c.Surname, "Second Name");
var tableDependency = new SqlTableDependency <DatabaseObjectAutoCleanUpAfter2InsertsTestSqlServerModel>(ConnectionString, TableName, mapper);
tableDependency.OnChanged += TableDependency_OnChanged;
tableDependency.Start();
var dbObjectsNaming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(500);
tableDependency.StopWithoutDisposing();
Thread.Sleep(500);
var t = new Task(ModifyTableContent);
t.Start();
Thread.Sleep(1000 * 60 * 4);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(dbObjectsNaming));
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(dbObjectsNaming));
}
public void EventForAllColumnsTest()
{
SqlTableDependency <EventForAllColumnsTestSqlServerModel> tableDependency = null;
string naming = null;
try
{
var mapper = new ModelToTableMapper <EventForAllColumnsTestSqlServerModel>();
mapper.AddMapping(c => c.Name, "FIRST name").AddMapping(c => c.Surname, "Second Name");
tableDependency = new SqlTableDependency <EventForAllColumnsTestSqlServerModel>(_connectionString, TableName, mapper);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
naming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(20000);
}
finally
{
tableDependency?.Dispose();
}
Assert.AreEqual(_counter, 3);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Surname, _checkValues[ChangeType.Insert.ToString()].Item1.Surname);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Surname, _checkValues[ChangeType.Update.ToString()].Item1.Surname);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Surname, _checkValues[ChangeType.Delete.ToString()].Item1.Surname);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(naming));
}
public void TaskCancellationTest()
{
string naming = null;
SqlTableDependency <TaskCancellationTestSqlServerModel> tableDependency = null;
try
{
var mapper = new ModelToTableMapper <TaskCancellationTestSqlServerModel>();
mapper.AddMapping(c => c.Name, "First Name").AddMapping(c => c.Surname, "Second Name");
tableDependency = new SqlTableDependency <TaskCancellationTestSqlServerModel>(ConnectionString, TableName, mapper);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
naming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
tableDependency.Stop();
Thread.Sleep(5000);
}
catch
{
tableDependency?.Dispose();
}
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(naming));
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(naming));
}
public void RaiseException1()
{
SqlTableDependency <TriggerTypeTestSqlServerModel> tableDependency = null;
string naming = null;
var updateOf = new UpdateOfModel <TriggerTypeTestSqlServerModel>();
updateOf.Add(i => i.Surname);
try
{
tableDependency = new SqlTableDependency <TriggerTypeTestSqlServerModel>(
ConnectionString,
tableName: TableName,
updateOf: updateOf,
notifyOn: DmlTriggerType.Insert);
naming = tableDependency.DataBaseObjectsNamingConvention;
}
finally
{
tableDependency?.Dispose();
}
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(naming));
}
public void ColumnTypesTest1()
{
SqlTableDependency <NVarcharMaxAndVarcharMaxModel> tableDependency = null;
string naming;
try
{
tableDependency = new SqlTableDependency <NVarcharMaxAndVarcharMaxModel>(ConnectionString, TableName);
tableDependency.OnChanged += this.TableDependency_Changed;
tableDependency.Start();
naming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
var t = new Task(ModifyTableContent1);
t.Start();
t.Wait(20000);
}
finally
{
tableDependency?.Dispose();
}
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.varcharMAXColumn, CheckValues[ChangeType.Insert.ToString()].Item1.varcharMAXColumn);
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.nvarcharMAXColumn, CheckValues[ChangeType.Insert.ToString()].Item1.nvarcharMAXColumn);
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.varcharMAXColumn, CheckValues[ChangeType.Update.ToString()].Item1.varcharMAXColumn);
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.nvarcharMAXColumn, CheckValues[ChangeType.Update.ToString()].Item1.nvarcharMAXColumn);
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.varcharMAXColumn, CheckValues[ChangeType.Delete.ToString()].Item1.varcharMAXColumn);
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.nvarcharMAXColumn, CheckValues[ChangeType.Delete.ToString()].Item1.nvarcharMAXColumn);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(naming));
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(naming));
}
public void EventForAllColumnsTest()
{
SqlTableDependency <EventForAllColumnsTestSqlServerModel> tableDependency = null;
string naming;
try
{
var mapper = new ModelToTableMapper <EventForAllColumnsTestSqlServerModel>();
mapper.AddMapping(c => c.Name, "FIRST name").AddMapping(c => c.Surname, "Second Name");
tableDependency = new SqlTableDependency <EventForAllColumnsTestSqlServerModel>(ConnectionString, TableName, mapper);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
naming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(500);
var t = new Task(ModifyTableContent);
t.Start();
Thread.Sleep(1000 * 60 * 1);
}
finally
{
tableDependency?.Dispose();
}
Assert.AreEqual(_counter, 0);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(naming));
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(naming));
}
public void OnlyUdate()
{
SqlTableDependency <TriggerTypeTestSqlServerModel> tableDependency = null;
string naming = null;
try
{
tableDependency = new SqlTableDependency <TriggerTypeTestSqlServerModel>(
ConnectionString,
tableName: TableName,
notifyOn: DmlTriggerType.Update);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
naming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(20000);
}
finally
{
tableDependency?.Dispose();
}
Assert.AreEqual(_counter, 1);
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Name, "Pizza Funghi");
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Surname, "Pizza Mergherita");
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(naming));
}
public void TableWithTest()
{
SqlTableDependency <SchemaNotDboTestSqlServerModel> tableDependency = null;
string naming = null;
try
{
tableDependency = new SqlTableDependency <SchemaNotDboTestSqlServerModel>(_connectionString, SchemaName + "." + TableName);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
naming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(20000);
}
finally
{
tableDependency?.Dispose();
}
Assert.AreEqual(_counter, 3);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(naming));
}
public void EventForAllColumnsTest()
{
SqlTableDependency <NoTableAndColumnDefinitionsTestSqlServerModel> tableDependency = null;
string naming = null;
try
{
tableDependency = new SqlTableDependency <NoTableAndColumnDefinitionsTestSqlServerModel>(ConnectionString);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
naming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(20000);
}
finally
{
tableDependency?.Dispose();
}
Assert.AreEqual(_counter, 3);
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Name, CheckValues[ChangeType.Insert.ToString()].Item1.Name);
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Surname, CheckValues[ChangeType.Insert.ToString()].Item1.Surname);
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Name, CheckValues[ChangeType.Update.ToString()].Item1.Name);
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Surname, CheckValues[ChangeType.Update.ToString()].Item1.Surname);
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Name, CheckValues[ChangeType.Delete.ToString()].Item1.Name);
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Surname, CheckValues[ChangeType.Delete.ToString()].Item1.Surname);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(ConnectionString, naming));
}
public void UpdateOneInterestedColumn()
{
SqlTableDependency <ABCTableModel> tableDependency = null;
string naming = null;
try
{
var mapper = new ModelToTableMapper <ABCTableModel>();
mapper.AddMapping(c => c.Name, "FIRST name").AddMapping(c => c.Surname, "Second NAME");
tableDependency = new SqlTableDependency <ABCTableModel>(_connectionString, TableName, mapper);
tableDependency.OnChanged += TableDependency_Changed1;
tableDependency.Start();
naming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
var t = new Task(ModifyTableContent1);
t.Start();
t.Wait(20000);
}
finally
{
tableDependency?.Dispose();
}
Assert.AreEqual(_counter1, 2);
Assert.AreEqual(_checkValues1[0].Item2.Name, _checkValues1[0].Item1.Name);
Assert.AreEqual(_checkValues1[0].Item2.Surname, _checkValues1[0].Item1.Surname);
Assert.AreEqual(_checkValues1[1].Item2.Name, _checkValues1[1].Item1.Name);
Assert.AreEqual(_checkValues1[1].Item2.Surname, _checkValues1[1].Item1.Surname);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(_connectionString, naming));
}
public void RaiseException1()
{
SqlTableDependency <TriggerTypeTestSqlServerModel> tableDependency = null;
string naming = null;
try
{
tableDependency = new SqlTableDependency <TriggerTypeTestSqlServerModel>(
ConnectionString,
TableName,
null,
new List <string>()
{
"second name"
},
DmlTriggerType.Insert,
true);
naming = tableDependency.DataBaseObjectsNamingConvention;
}
finally
{
tableDependency?.Dispose();
}
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(ConnectionString, naming));
}
public void DatabaseObjectCleanUpTest()
{
var mapper = new ModelToTableMapper <EventForAllColumnsTestSqlServerModel>();
mapper.AddMapping(c => c.Name, "FIRST name").AddMapping(c => c.Surname, "Second Name");
var tableDependency = new SqlTableDependency <EventForAllColumnsTestSqlServerModel>(ConnectionString, TableName, mapper);
tableDependency.OnChanged += TableDependency_OnChanged;
tableDependency.Start();
_dbObjectsNaming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(50);
var t = new Task(BigModifyTableContent);
t.Start();
t.Wait(10000);
Thread.Sleep(1000 * 30 * 1);
tableDependency.Stop();
SmalModifyTableContent();
Thread.Sleep(4 * 60 * 1000);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(_dbObjectsNaming));
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(_dbObjectsNaming));
}
public void Test()
{
var namingToUse = "CustomNaming";
var mapper = new ModelToTableMapper <NoDisposeAndRestartWithSameObjectsTestSqlServerModel>();
mapper.AddMapping(c => c.Name, "FIRST name").AddMapping(c => c.Surname, "Second Name");
RunFirstTime(namingToUse);
Thread.Sleep(3 * 60 * 1000);
using (var tableDependency = new SqlTableDependency <NoDisposeAndRestartWithSameObjectsTestSqlServerModel>(ConnectionString, TableName, mapper, true, namingToUse))
{
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
Assert.AreEqual(tableDependency.DataBaseObjectsNamingConvention, namingToUse);
Thread.Sleep(1 * 25 * 1000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(1 * 60 * 1000);
}
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(ConnectionString, namingToUse));
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Surname, _checkValues[ChangeType.Insert.ToString()].Item1.Surname);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Surname, _checkValues[ChangeType.Update.ToString()].Item1.Surname);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Surname, _checkValues[ChangeType.Delete.ToString()].Item1.Surname);
}
public void TeardownTests()
{
SqlTableDependency <TeardownTestSqlserver5Model> tableDependency = null;
string dataBaseObjectsNamingConvention = null;
var mapper = new ModelToTableMapper <TeardownTestSqlserver5Model>();
mapper.AddMapping(c => c.Description, "Long Description");
////////////////////////////////////////////////////////
// First Round
////////////////////////////////////////////////////////
try
{
tableDependency = new SqlTableDependency <TeardownTestSqlserver5Model>(ConnectionString, mapper: mapper, teardown: false);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
dataBaseObjectsNamingConvention = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
}
finally
{
tableDependency?.Dispose();
}
Thread.Sleep(5000);
////////////////////////////////////////////////////////
// Inserd data while sql table dependency is not running
////////////////////////////////////////////////////////
ModifyTableContent();
////////////////////////////////////////////////////////
// Second Round
////////////////////////////////////////////////////////
tableDependency = new SqlTableDependency <TeardownTestSqlserver5Model>(ConnectionString, mapper: mapper, teardown: true, namingForObjectsAlreadyExisting: dataBaseObjectsNamingConvention);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
Thread.Sleep(5000);
tableDependency.Stop();
Thread.Sleep(3 * 60 * 1000);
Assert.AreEqual(_counter, 1000);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(ConnectionString, dataBaseObjectsNamingConvention));
}
public void AfterThreeMinutesICanGetNotifications()
{
SqlTableDependency <MoChangModel2> tableDependency = null;
string dataBaseObjectsNamingConvention = null;
try
{
tableDependency = new SqlTableDependency <MoChangModel2>(ConnectionString);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
dataBaseObjectsNamingConvention = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(4 * 60 * 1000);
Assert.IsFalse(SqlServerHelper.AreAllDbObjectDisposed(dataBaseObjectsNamingConvention));
var t = new Task(ModifyTableContent);
t.Start();
Thread.Sleep(20000);
Assert.AreEqual(_counter, 3);
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Name, "Pizza Mergherita" + Mal);
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Surname, "Pizza Mergherita" + Mal);
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Name, "Pizza Funghi" + Mal);
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Surname, "Pizza Mergherita" + Mal);
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Name, "Pizza Funghi" + Mal);
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Surname, "Pizza Mergherita" + Mal);
Mal = "Second round";
_counter = 0;
CheckValues = new Dictionary <string, Tuple <MoChangModel2, MoChangModel2> >();
Thread.Sleep(7 * 60 * 1000);
t = new Task(ModifyTableContent);
t.Start();
Thread.Sleep(20000);
Assert.AreEqual(_counter, 3);
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Name, "Pizza Mergherita" + Mal);
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Surname, "Pizza Mergherita" + Mal);
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Name, "Pizza Funghi" + Mal);
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Surname, "Pizza Mergherita" + Mal);
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Name, "Pizza Funghi" + Mal);
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Surname, "Pizza Mergherita" + Mal);
}
finally
{
tableDependency?.Dispose();
}
Thread.Sleep(5000);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(dataBaseObjectsNamingConvention));
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(dataBaseObjectsNamingConvention));
}
public void Test()
{
SqlTableDependency <ModelGuidSmallMoneyTypes> tableDependency = null;
string naming;
try
{
tableDependency = new SqlTableDependency <ModelGuidSmallMoneyTypes>(_connectionString, TableName);
tableDependency.OnChanged += this.TableDependency_Changed;
tableDependency.Start();
naming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(20000);
}
finally
{
tableDependency?.Dispose();
}
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.uniqueidentifierColumn, _checkValues[ChangeType.Insert.ToString()].Item1.uniqueidentifierColumn);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.time7Column, _checkValues[ChangeType.Insert.ToString()].Item1.time7Column);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.tinyintColumn, _checkValues[ChangeType.Insert.ToString()].Item1.tinyintColumn);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.smalldatetimeColumn, _checkValues[ChangeType.Insert.ToString()].Item1.smalldatetimeColumn);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.smallintColumn, _checkValues[ChangeType.Insert.ToString()].Item1.smallintColumn);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.moneyColumn, _checkValues[ChangeType.Insert.ToString()].Item1.moneyColumn);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.smallmoneyColumn, _checkValues[ChangeType.Insert.ToString()].Item1.smallmoneyColumn);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.smallintColumn, _checkValues[ChangeType.Update.ToString()].Item1.smallintColumn);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.time7Column, _checkValues[ChangeType.Update.ToString()].Item1.time7Column);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.tinyintColumn, _checkValues[ChangeType.Update.ToString()].Item1.tinyintColumn);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.smalldatetimeColumn, _checkValues[ChangeType.Update.ToString()].Item1.smalldatetimeColumn);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.smallintColumn, _checkValues[ChangeType.Update.ToString()].Item1.smallintColumn);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.moneyColumn, _checkValues[ChangeType.Update.ToString()].Item1.moneyColumn);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.smallmoneyColumn, _checkValues[ChangeType.Update.ToString()].Item1.smallmoneyColumn);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.smallintColumn, _checkValues[ChangeType.Delete.ToString()].Item1.smallintColumn);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.time7Column, _checkValues[ChangeType.Delete.ToString()].Item1.time7Column);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.tinyintColumn, _checkValues[ChangeType.Delete.ToString()].Item1.tinyintColumn);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.smalldatetimeColumn, _checkValues[ChangeType.Delete.ToString()].Item1.smalldatetimeColumn);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.smallintColumn, _checkValues[ChangeType.Delete.ToString()].Item1.smallintColumn);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.moneyColumn, _checkValues[ChangeType.Delete.ToString()].Item1.moneyColumn);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.smallmoneyColumn, _checkValues[ChangeType.Delete.ToString()].Item1.smallmoneyColumn);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(_connectionString, naming));
}
public void DatabaseObjectCleanUpTest()
{
var tableDependency = new SqlTableDependency <EventForAllColumnsTestSqlServerModel>(ConnectionString, TableName);
tableDependency.OnChanged += TableDependency_OnChanged;
tableDependency.Start();
_dbObjectsNaming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
tableDependency.StopWithoutDisposing();
Thread.Sleep(4 * 60 * 1000);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(_dbObjectsNaming));
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(_dbObjectsNaming));
}
public void DatabaseObjectCleanUpTest()
{
var domaininfo = new AppDomainSetup();
domaininfo.ApplicationBase = Environment.CurrentDirectory;
var adevidence = AppDomain.CurrentDomain.Evidence;
var domain = AppDomain.CreateDomain("RunsInAnotherAppDomain_Check_DatabaseObjectCleanUp", adevidence, domaininfo);
var otherDomainObject = (RunsInAnotherAppDomain_Check_DatabaseObjectCleanUp)domain.CreateInstanceAndUnwrap(typeof(RunsInAnotherAppDomain_Check_DatabaseObjectCleanUp).Assembly.FullName, typeof(RunsInAnotherAppDomain_Check_DatabaseObjectCleanUp).FullName);
_dbObjectsNaming = otherDomainObject.RunTableDependency(ConnectionString, TableName);
Thread.Sleep(5000);
AppDomain.Unload(domain);
Thread.Sleep(3 * 60 * 1000);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(ConnectionString, _dbObjectsNaming));
}
public void Test()
{
SqlTableDependency <ModelWithAnnotationUsedWithCunstructorParameterTestSqlServerModel> tableDependency = null;
string naming = null;
var mapper = new ModelToTableMapper <ModelWithAnnotationUsedWithCunstructorParameterTestSqlServerModel>();
mapper.AddMapping(c => c.Infos, "More Info");
var updateOf = new UpdateOfModel <ModelWithAnnotationUsedWithCunstructorParameterTestSqlServerModel>();
updateOf.Add(i => i.Infos);
try
{
tableDependency = new SqlTableDependency <ModelWithAnnotationUsedWithCunstructorParameterTestSqlServerModel>(ConnectionString, tableName: TableName, mapper: mapper, updateOf: updateOf);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
naming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(30000);
}
finally
{
tableDependency?.Dispose();
}
Assert.AreEqual(_counter, 3);
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Name, "Pizza MERGHERITA");
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Infos, "Pizza MERGHERITA");
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Name, "Pizza MERGHERITA");
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Infos, "FUNGHI PORCINI");
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Name, "Pizza");
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Infos, "FUNGHI PORCINI");
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(naming));
}
public void Issue27Tesst()
{
var mapper = new ModelToTableMapper <Issue55Model>();
mapper.AddMapping(c => c.PaymentDiscount, "Payment Discount %");
mapper.AddMapping(c => c.AllowQuantity, "Allow Quantity Disc_");
mapper.AddMapping(c => c.DocNo, "Applies-to Doc_ No_");
string objectNaming;
var tableDependency = new SqlTableDependency <Issue55Model>(ConnectionString, TableName, mapper);
try
{
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
objectNaming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(20000);
}
finally
{
tableDependency.Dispose();
}
Assert.AreEqual(_counter, 3);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.DocNo, _checkValues[ChangeType.Insert.ToString()].Item1.DocNo);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.AllowQuantity, _checkValues[ChangeType.Insert.ToString()].Item1.AllowQuantity);
Assert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.PaymentDiscount, _checkValues[ChangeType.Insert.ToString()].Item1.PaymentDiscount);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.DocNo, _checkValues[ChangeType.Update.ToString()].Item1.DocNo);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.AllowQuantity, _checkValues[ChangeType.Update.ToString()].Item1.AllowQuantity);
Assert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.PaymentDiscount, _checkValues[ChangeType.Update.ToString()].Item1.PaymentDiscount);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.DocNo, _checkValues[ChangeType.Delete.ToString()].Item1.DocNo);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.AllowQuantity, _checkValues[ChangeType.Delete.ToString()].Item1.AllowQuantity);
Assert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.PaymentDiscount, _checkValues[ChangeType.Delete.ToString()].Item1.PaymentDiscount);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(objectNaming));
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(objectNaming));
}
public void Test()
{
var domaininfo = new AppDomainSetup();
domaininfo.ApplicationBase = Environment.CurrentDirectory;
var adevidence = AppDomain.CurrentDomain.Evidence;
var domain = AppDomain.CreateDomain("TableDependencyDomaing", adevidence, domaininfo);
var otherDomainObject = (RunsInAnotherAppDomainNoMessage)domain.CreateInstanceAndUnwrap(typeof(RunsInAnotherAppDomainNoMessage).Assembly.FullName, typeof(RunsInAnotherAppDomainNoMessage).FullName);
_dbObjectsNaming = otherDomainObject.RunTableDependency(ConnectionString, TableName);
Thread.Sleep(4 * 60 * 1000);
var status = otherDomainObject.GetTableDependencyStatus();
AppDomain.Unload(domain);
Thread.Sleep(3 * 60 * 1000);
Assert.IsTrue(status != TableDependencyStatus.StopDueToError && status != TableDependencyStatus.StopDueToCancellation);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(_dbObjectsNaming));
}
public void EventForAllColumnsTest()
{
SqlTableDependency <DataAnnotationTestSelServerModel4> tableDependency = null;
string naming = null;
var mapper = new ModelToTableMapper <DataAnnotationTestSelServerModel4>();
mapper.AddMapping(c => c.Description, "Long Description");
try
{
tableDependency = new SqlTableDependency <DataAnnotationTestSelServerModel4>(ConnectionString, tableName: "ANItemsTableSQL4", mapper: mapper);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
naming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(20000);
}
finally
{
tableDependency?.Dispose();
}
Assert.AreEqual(_counter, 3);
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Name, CheckValues[ChangeType.Insert.ToString()].Item1.Name);
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Description, CheckValues[ChangeType.Insert.ToString()].Item1.Description);
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Name, CheckValues[ChangeType.Update.ToString()].Item1.Name);
Assert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Description, CheckValues[ChangeType.Update.ToString()].Item1.Description);
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Name, CheckValues[ChangeType.Delete.ToString()].Item1.Name);
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Description, CheckValues[ChangeType.Delete.ToString()].Item1.Description);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(naming));
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(naming));
}
public void Test()
{
using (var tableDependency = new SqlTableDependency <GetMessageAfterRestartTestSqlServerModel>(
ConnectionString,
TableName,
mapper: null,
updateOf: (List <string>)null,
automaticDatabaseObjectsTeardown: false,
namingConventionForDatabaseObjects: NamingToUse))
{
tableDependency.OnChanged += (object sender, RecordChangedEventArgs <GetMessageAfterRestartTestSqlServerModel> e) => { };
tableDependency.Start(60, 120);
}
Thread.Sleep(2 * 60 * 1000);
Assert.IsFalse(SqlServerHelper.AreAllDbObjectDisposed(ConnectionString, NamingToUse));
ModifyTableContent();
var domaininfo = new AppDomainSetup {
ApplicationBase = Environment.CurrentDirectory
};
var adevidence = AppDomain.CurrentDomain.Evidence;
var domain = AppDomain.CreateDomain("AppDomGetMessageAfterRestart", adevidence, domaininfo);
var otherDomainObject = (AppDomGetMessageAfterRestart)domain.CreateInstanceAndUnwrap(typeof(AppDomGetMessageAfterRestart).Assembly.FullName, typeof(AppDomGetMessageAfterRestart).FullName);
var nameUsed = otherDomainObject.RunTableDependency(ConnectionString, TableName, NamingToUse);
Thread.Sleep(1 * 60 * 1000);
var checkValues = otherDomainObject.GetResult();
otherDomainObject.DisposeTableDependency();
AppDomain.Unload(domain);
var results = checkValues.Split(',');
Assert.AreEqual("Valentina", results[0]);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(ConnectionString, nameUsed));
}
public void StatusTest()
{
try
{
var mapper = new ModelToTableMapper <StatusTestSqlServerModel>();
mapper.AddMapping(c => c.Name, "FIRST name");
mapper.AddMapping(c => c.Surname, "Second Name");
this._tableDependency = new SqlTableDependency <StatusTestSqlServerModel>(ConnectionString, TableName, mapper);
this._tableDependency.OnChanged += this.TableDependency_Changed;
this._tableDependency.OnStatusChanged += this.TableDependency_OnStatusChanged;
this._tableDependency.OnError += this.TableDependency_OnError;
var dataBaseObjectsNamingConvention = _tableDependency.DataBaseObjectsNamingConvention;
this._tableDependency.Start();
Thread.Sleep(1 * 60 * 1000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(5000);
this._tableDependency.Stop();
t.Wait(100);
Assert.IsTrue(statuses[TableDependencyStatus.Starting]);
Assert.IsTrue(statuses[TableDependencyStatus.Started]);
Assert.IsTrue(statuses[TableDependencyStatus.WaitingForNotification]);
Assert.IsTrue(statuses[TableDependencyStatus.StopDueToCancellation]);
Assert.IsFalse(statuses[TableDependencyStatus.StopDueToError]);
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(dataBaseObjectsNamingConvention));
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(dataBaseObjectsNamingConvention));
}
finally
{
this._tableDependency?.Dispose();
}
}
public void LoadAndCountTest()
{
var cts = new CancellationTokenSource(TimeSpan.FromMinutes(10));
var token = cts.Token;
var counterUpTo = 1000;
var mapper = new ModelToTableMapper <LoadAndCountTestSqlServerModel>();
mapper.AddMapping(c => c.Name, "First Name").AddMapping(c => c.Surname, "Second Name");
var listenerTask = Task.Factory.StartNew(() => new ListenerSlq(ConnectionString, TableName, mapper).Run(counterUpTo, token), token);
Thread.Sleep(3000);
using (var sqlConnection = new SqlConnection(ConnectionString))
{
sqlConnection.Open();
using (var sqlCommand = sqlConnection.CreateCommand())
{
while (!listenerTask.IsCompleted)
{
if (this._counter <= counterUpTo)
{
sqlCommand.CommandText = $"INSERT INTO [{TableName}] ([First Name], [Second Name]) VALUES ('{DateTime.Now.Ticks}', '{this._counter}')";
sqlCommand.ExecuteNonQuery();
this._counter++;
}
Thread.Sleep(250);
}
}
}
Assert.IsTrue(listenerTask.Result != null);
Assert.IsTrue(listenerTask.Result.Counter == counterUpTo);
Assert.IsTrue(!listenerTask.Result.SequentialNotificationFailed);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(listenerTask.Result.ObjectNaming));
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(listenerTask.Result.ObjectNaming));
}
public void Issue27Tesst()
{
try
{
string objectNaming;
using (var tableDependency = new SqlTableDependency <Issue27Model>(ConnectionString, TableName))
{
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
objectNaming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
}
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(ConnectionString, objectNaming));
}
catch (Exception exception)
{
TestContext.WriteLine(exception.Message);
Assert.Fail();
}
}
public void Test()
{
SqlTableDependency <AAA_Item3> tableDependency = null;
string naming = null;
try
{
UpdateOfModel <AAA_Item3> updateOF = new UpdateOfModel <AAA_Item3>();
updateOF.Add(model => model.FamilyName);
tableDependency = new SqlTableDependency <AAA_Item3>(ConnectionString, updateOf: updateOF);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
naming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(30000);
}
finally
{
tableDependency?.Dispose();
}
Assert.AreEqual(_counter, 2);
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Name, CheckValues[ChangeType.Insert.ToString()].Item1.Name);
Assert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.FamilyName, CheckValues[ChangeType.Insert.ToString()].Item1.FamilyName);
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Name, CheckValues[ChangeType.Delete.ToString()].Item1.Name);
Assert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.FamilyName, CheckValues[ChangeType.Delete.ToString()].Item1.FamilyName);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(naming));
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(naming));
}
public void DatabaseObjectCleanUpTest()
{
var mapper = new ModelToTableMapper <DatabaseObjectAutoCleanUpAfterHugeInsertsTestSqlServerModel>();
mapper.AddMapping(c => c.Name, "First Name").AddMapping(c => c.Surname, "Second Name");
var tableDependency = new SqlTableDependency <DatabaseObjectAutoCleanUpAfterHugeInsertsTestSqlServerModel>(ConnectionString, TableName, mapper);
tableDependency.OnChanged += TableDependency_OnChanged;
tableDependency.Start();
var dbObjectsNaming = tableDependency.DataBaseObjectsNamingConvention;
Thread.Sleep(5000);
tableDependency.StopWithoutDisposing();
Thread.Sleep(1000);
using (var sqlConnection = new SqlConnection(ConnectionString))
{
sqlConnection.Open();
using (var sqlCommand = sqlConnection.CreateCommand())
{
for (var i = 0; i < 10000; i++)
{
sqlCommand.CommandText = $"INSERT INTO [{TableName}] ([First Name], [Second Name]) VALUES ('{i}', '{i}')";
sqlCommand.ExecuteNonQuery();
}
}
sqlConnection.Close();
}
Thread.Sleep(1000 * 60 * 3);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(dbObjectsNaming));
Assert.IsTrue(SqlServerHelper.AreAllEndpointDisposed(dbObjectsNaming));
}
public static void AssemblyCleanup()
{
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(_dbObjectsNaming));
}
public void TeardownTests()
{
string naming = "TestTeardown4";
SqlTableDependency <TeardownTestSqlserver4Model> tableDependency = null;
string dataBaseObjectsNamingConvention = null;
var mapper = new ModelToTableMapper <TeardownTestSqlserver4Model>();
mapper.AddMapping(c => c.Description, "Long Description");
////////////////////////////////////////////////////////
// First Round
////////////////////////////////////////////////////////
try
{
tableDependency = new SqlTableDependency <TeardownTestSqlserver4Model>(ConnectionString, mapper: mapper, teardown: false, namingForObjectsAlreadyExisting: naming);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
dataBaseObjectsNamingConvention = tableDependency.DataBaseObjectsNamingConvention;
Assert.AreEqual(dataBaseObjectsNamingConvention, naming);
Thread.Sleep(5000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(10000);
}
finally
{
tableDependency?.Dispose();
}
Assert.AreEqual(_notifiedValues.Count, 3);
Assert.AreEqual(_insertedValues[0].Id, _notifiedValues[0].Id);
Assert.AreEqual(_insertedValues[0].Name, _notifiedValues[0].Name);
Assert.AreEqual(_insertedValues[0].Description, _notifiedValues[0].Description);
Assert.AreEqual(_insertedValues[1].Id, _notifiedValues[1].Id);
Assert.AreEqual(_insertedValues[1].Name, _notifiedValues[1].Name);
Assert.AreEqual(_insertedValues[1].Description, _notifiedValues[1].Description);
Assert.AreEqual(_insertedValues[2].Id, _notifiedValues[2].Id);
Assert.AreEqual(_insertedValues[2].Name, _notifiedValues[2].Name);
Assert.AreEqual(_insertedValues[2].Description, _notifiedValues[2].Description);
Assert.IsFalse(SqlServerHelper.AreAllDbObjectDisposed(ConnectionString, naming));
////////////////////////////////////////////////////////
// Inserd data while sql table dependency is not running
////////////////////////////////////////////////////////
ModifyTableContent();
////////////////////////////////////////////////////////
// Second Round
////////////////////////////////////////////////////////
try
{
tableDependency.Start();
dataBaseObjectsNamingConvention = tableDependency.DataBaseObjectsNamingConvention;
Assert.AreEqual(dataBaseObjectsNamingConvention, naming);
Thread.Sleep(5000);
var t = new Task(ModifyTableContent);
t.Start();
t.Wait(10000);
}
finally
{
tableDependency.Stop();
}
Assert.AreEqual(_notifiedValues.Count, 9);
Assert.AreEqual(_insertedValues[3].Id, _notifiedValues[3].Id);
Assert.AreEqual(_insertedValues[3].Name, _notifiedValues[3].Name);
Assert.AreEqual(_insertedValues[3].Description, _notifiedValues[3].Description);
Assert.AreEqual(_insertedValues[4].Id, _notifiedValues[4].Id);
Assert.AreEqual(_insertedValues[4].Name, _notifiedValues[4].Name);
Assert.AreEqual(_insertedValues[4].Description, _notifiedValues[4].Description);
Assert.AreEqual(_insertedValues[5].Id, _notifiedValues[5].Id);
Assert.AreEqual(_insertedValues[5].Name, _notifiedValues[5].Name);
Assert.AreEqual(_insertedValues[5].Description, _notifiedValues[5].Description);
Assert.AreEqual(_insertedValues[6].Id, _notifiedValues[6].Id);
Assert.AreEqual(_insertedValues[6].Name, _notifiedValues[6].Name);
Assert.AreEqual(_insertedValues[6].Description, _notifiedValues[6].Description);
Assert.AreEqual(_insertedValues[7].Id, _notifiedValues[7].Id);
Assert.AreEqual(_insertedValues[7].Name, _notifiedValues[7].Name);
Assert.AreEqual(_insertedValues[7].Description, _notifiedValues[7].Description);
Assert.AreEqual(_insertedValues[8].Id, _notifiedValues[8].Id);
Assert.AreEqual(_insertedValues[8].Name, _notifiedValues[8].Name);
Assert.AreEqual(_insertedValues[8].Description, _notifiedValues[8].Description);
Assert.IsFalse(SqlServerHelper.AreAllDbObjectDisposed(ConnectionString, naming));
tableDependency = new SqlTableDependency <TeardownTestSqlserver4Model>(ConnectionString, mapper: mapper, teardown: true, namingForObjectsAlreadyExisting: naming);
tableDependency.OnChanged += TableDependency_Changed;
tableDependency.Start();
Thread.Sleep(500);
tableDependency.Stop();
Thread.Sleep(5000);
Assert.IsTrue(SqlServerHelper.AreAllDbObjectDisposed(ConnectionString, naming));
}