System.Threading.Tasks.Task.Start()

Here are the examples of the csharp api System.Threading.Tasks.Task.Start() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

825 Examples 7

19 Source : DataAnnotationTest03.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        [ExpectedException(typeof(ModelToTableMapperException))]
        public void Test()
        {
            SqlTableDependency<DataAnnotationTestSqlServer3Model> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer3Model>(ConnectionStringForTestUser);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Update.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest03.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        [ExpectedException(typeof(ModelToTableMapperException))]
        public void TestWithOldValues()
        {
            SqlTableDependency<DataAnnotationTestSqlServer3Model> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer3Model>(ConnectionStringForTestUser);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item2.Name);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item2.Description);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : BinaryBitCharVarbinaryTypesTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void TestWithOldValues()
        {
            SqlTableDependency<BinaryreplacedarVarbinaryTypesModel> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<BinaryreplacedarVarbinaryTypesModel>(
                    ConnectionStringForTestUser,
                    TableName,
                    includeOldValues: true);

                tableDependency.OnChanged += this.TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(GetString(_checkValues[ChangeType.Insert.ToString()].Item2.Binary50Column), GetString(_checkValues[ChangeType.Insert.ToString()].Item1.Binary50Column));
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.BitColumn, _checkValues[ChangeType.Insert.ToString()].Item1.BitColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Char10Column, _checkValues[ChangeType.Insert.ToString()].Item1.Char10Column);
            replacedert.AreEqual(GetString(_checkValues[ChangeType.Insert.ToString()].Item2.Varbinary50Column), GetString(_checkValues[ChangeType.Insert.ToString()].Item1.Varbinary50Column));
            replacedert.AreEqual(GetString(_checkValues[ChangeType.Insert.ToString()].Item2.VarbinaryMaxColumn), GetString(_checkValues[ChangeType.Insert.ToString()].Item1.VarbinaryMaxColumn));

            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(GetString(_checkValues[ChangeType.Update.ToString()].Item2.Binary50Column), GetString(_checkValues[ChangeType.Update.ToString()].Item1.Binary50Column));
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.BitColumn, _checkValues[ChangeType.Update.ToString()].Item1.BitColumn);
            replacedert.AreEqual(new String(_checkValues[ChangeType.Update.ToString()].Item2.Char10Column).Trim(), new String(_checkValues[ChangeType.Update.ToString()].Item1.Char10Column).Trim());
            replacedert.AreEqual(GetString(_checkValues[ChangeType.Update.ToString()].Item2.Varbinary50Column), GetString(_checkValues[ChangeType.Update.ToString()].Item1.Varbinary50Column));
            replacedert.AreEqual(GetString(_checkValues[ChangeType.Update.ToString()].Item2.VarbinaryMaxColumn), GetString(_checkValues[ChangeType.Update.ToString()].Item1.VarbinaryMaxColumn));

            replacedert.AreEqual(GetString(_checkValuesOld[ChangeType.Update.ToString()].Item2.Binary50Column), GetString(_checkValues[ChangeType.Insert.ToString()].Item2.Binary50Column));
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.BitColumn, _checkValues[ChangeType.Insert.ToString()].Item2.BitColumn);
            replacedert.AreEqual(new String(_checkValuesOld[ChangeType.Update.ToString()].Item2.Char10Column).Trim(), new String(_checkValues[ChangeType.Insert.ToString()].Item2.Char10Column).Trim());
            replacedert.AreEqual(GetString(_checkValuesOld[ChangeType.Update.ToString()].Item2.Varbinary50Column), GetString(_checkValues[ChangeType.Insert.ToString()].Item2.Varbinary50Column));
            replacedert.AreEqual(GetString(_checkValuesOld[ChangeType.Update.ToString()].Item2.VarbinaryMaxColumn), GetString(_checkValues[ChangeType.Insert.ToString()].Item2.VarbinaryMaxColumn));

            replacedert.AreEqual(GetString(_checkValues[ChangeType.Delete.ToString()].Item2.Binary50Column), GetString(_checkValues[ChangeType.Delete.ToString()].Item1.Binary50Column));
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.BitColumn, _checkValues[ChangeType.Delete.ToString()].Item1.BitColumn);
            replacedert.AreEqual(new String(_checkValues[ChangeType.Delete.ToString()].Item2.Char10Column).Trim(), new String(_checkValues[ChangeType.Delete.ToString()].Item1.Char10Column).Trim());
            replacedert.AreEqual(GetString(_checkValues[ChangeType.Delete.ToString()].Item2.Varbinary50Column), GetString(_checkValues[ChangeType.Delete.ToString()].Item1.Varbinary50Column));
            replacedert.AreEqual(GetString(_checkValues[ChangeType.Delete.ToString()].Item2.VarbinaryMaxColumn), GetString(_checkValues[ChangeType.Delete.ToString()].Item1.VarbinaryMaxColumn));

            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : ComputedColumnTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<ComputedColumnModel> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<ComputedColumnModel>(ConnectionStringForTestUser);
                naming = tableDependency.DataBaseObjectsNamingConvention;
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Name, CheckValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.BirthDate, CheckValues[ChangeType.Insert.ToString()].Item1.BirthDate);
            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.CalculatedAge, CheckValues[ChangeType.Insert.ToString()].Item1.CalculatedAge);
            replacedert.IsNull(CheckValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Name, CheckValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.BirthDate, CheckValues[ChangeType.Update.ToString()].Item1.BirthDate);
            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.CalculatedAge, CheckValues[ChangeType.Update.ToString()].Item1.CalculatedAge);
            replacedert.IsNull(CheckValuesOld[ChangeType.Update.ToString()]);

            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Name, CheckValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.BirthDate, CheckValues[ChangeType.Delete.ToString()].Item1.BirthDate);
            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.CalculatedAge, CheckValues[ChangeType.Delete.ToString()].Item1.CalculatedAge);
            replacedert.IsNull(CheckValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : CultureInfoTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test1()
        {
            SqlTableDependency<CultureInfoTestModel> tableDependency = null;
            string naming;

            CheckValues1.Add(ChangeType.Insert.ToString(), new CultureInfoTestModel());
            CheckValues1.Add(ChangeType.Update.ToString(), new CultureInfoTestModel());
            CheckValues1.Add(ChangeType.Delete.ToString(), new CultureInfoTestModel());

            try
            {
                tableDependency = new SqlTableDependency<CultureInfoTestModel>(ConnectionStringForTestUser, TableName1);
                naming = tableDependency.DataBaseObjectsNamingConvention;
                tableDependency.OnChanged += TableDependency_Changed1;
                tableDependency.CultureInfo = new CultureInfo("it-IT");

                tableDependency.Start();
                var t = new Task(ModifyTableContent1);
                t.Start();
                Thread.Sleep(1000 * 10 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter1, 3);
           
            replacedert.AreEqual("Christian", CheckValues1[ChangeType.Insert.ToString()].Name);
            replacedert.AreEqual(DateTime.ParseExact("2009-08-05", "yyyy-MM-dd", new CultureInfo("it-IT")), CheckValues1[ChangeType.Insert.ToString()].BirthDate);

            replacedert.AreEqual("Valentina", CheckValues1[ChangeType.Update.ToString()].Name);
            replacedert.AreEqual(DateTime.ParseExact("2009-05-08", "yyyy-MM-dd", new CultureInfo("it-IT")), CheckValues1[ChangeType.Update.ToString()].BirthDate);
            
            replacedert.AreEqual("Valentina", CheckValues1[ChangeType.Delete.ToString()].Name);
            replacedert.AreEqual(DateTime.ParseExact("2009-05-08", "yyyy-MM-dd", new CultureInfo("it-IT")), CheckValues1[ChangeType.Delete.ToString()].BirthDate);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationNotMappedTest1.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test1()
        {
            SqlTableDependency<DataAnnotationNotMappedTest1Model> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<DataAnnotationNotMappedTest1Model>(
                    ConnectionStringForTestUser,
                    includeOldValues: false,
                    schemaName: ScemaName);

                tableDependency.OnChanged += TableDependency_Changed_Test1;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                Thread.Sleep(5000);

                var t = new Task(ModifyTableContentTest1);
                t.Start();
                Thread.Sleep(1000 * 5 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }


            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValuesTest1[ChangeType.Insert.ToString()].Item2.StringNumberInDatabase, _checkValuesTest1[ChangeType.Insert.ToString()].Item1.StringNumberInDatabase);
            replacedert.AreEqual(_checkValuesTest1[ChangeType.Insert.ToString()].Item2.Number, int.Parse(_checkValuesTest1[ChangeType.Insert.ToString()].Item1.StringNumberInDatabase));

            replacedert.AreEqual(_checkValuesTest1[ChangeType.Update.ToString()].Item2.StringNumberInDatabase, _checkValuesTest1[ChangeType.Update.ToString()].Item1.StringNumberInDatabase);
            replacedert.AreEqual(_checkValuesTest1[ChangeType.Update.ToString()].Item2.Number, int.Parse(_checkValuesTest1[ChangeType.Update.ToString()].Item1.StringNumberInDatabase));

            replacedert.AreEqual(_checkValuesTest1[ChangeType.Delete.ToString()].Item2.StringNumberInDatabase, _checkValuesTest1[ChangeType.Delete.ToString()].Item1.StringNumberInDatabase);
            replacedert.AreEqual(_checkValuesTest1[ChangeType.Delete.ToString()].Item2.Number, int.Parse(_checkValuesTest1[ChangeType.Update.ToString()].Item1.StringNumberInDatabase));

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationNotMappedTest2.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test2()
        {
            SqlTableDependency<DataAnnotationNotMappedTest2Model> tableDependency = null;
            string naming;

            try
            {
                var mapper = new ModelToTableMapper<DataAnnotationNotMappedTest2Model>();
                mapper.AddMapping(c => c.Description, "Long Description");

                tableDependency = new SqlTableDependency<DataAnnotationNotMappedTest2Model>(
                    ConnectionStringForTestUser, 
                    includeOldValues: false,
                    schemaName: ScemaName, 
                    mapper: mapper);

                tableDependency.OnChanged += TableDependency_Changed_Test2;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                Thread.Sleep(5000);

                var t = new Task(ModifyTableContentTest2);
                t.Start();
                Thread.Sleep(1000 * 5 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValuesTest2[ChangeType.Insert.ToString()].Item2.Id, _checkValuesTest2[ChangeType.Insert.ToString()].Item1.Id);
            replacedert.AreEqual(_checkValuesTest2[ChangeType.Insert.ToString()].Item2.Name, _checkValuesTest2[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValuesTest2[ChangeType.Insert.ToString()].Item2.Description, _checkValuesTest2[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.AreEqual(_checkValuesTest2[ChangeType.Insert.ToString()].Item2.ComposedName, _checkValuesTest2[ChangeType.Insert.ToString()].Item1.ComposedName);

            replacedert.AreEqual(_checkValuesTest2[ChangeType.Update.ToString()].Item2.Id, _checkValuesTest2[ChangeType.Update.ToString()].Item1.Id);
            replacedert.AreEqual(_checkValuesTest2[ChangeType.Update.ToString()].Item2.Name, _checkValuesTest2[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValuesTest2[ChangeType.Update.ToString()].Item2.Description, _checkValuesTest2[ChangeType.Update.ToString()].Item1.Description);
            replacedert.AreEqual(_checkValuesTest2[ChangeType.Update.ToString()].Item2.ComposedName, _checkValuesTest2[ChangeType.Update.ToString()].Item1.ComposedName);

            replacedert.AreEqual(_checkValuesTest2[ChangeType.Delete.ToString()].Item2.Id, _checkValuesTest2[ChangeType.Delete.ToString()].Item1.Id);
            replacedert.AreEqual(_checkValuesTest2[ChangeType.Delete.ToString()].Item2.Name, _checkValuesTest2[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValuesTest2[ChangeType.Delete.ToString()].Item2.Description, _checkValuesTest2[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.AreEqual(_checkValuesTest2[ChangeType.Delete.ToString()].Item2.ComposedName, _checkValuesTest2[ChangeType.Delete.ToString()].Item1.ComposedName);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest06.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        [ExpectedException(typeof(NotExistingTableException))]
        public void Test()
        {
            SqlTableDependency<DataAnnotationTestSqlServer6Model> tableDependency = null;
            string naming = null;

            try
            {
                var mapper = new ModelToTableMapper<DataAnnotationTestSqlServer6Model>();
                mapper.AddMapping(c => c.Description, "Long Description");

                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer6Model>(ConnectionStringForTestUser);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Update.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest06.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        [ExpectedException(typeof(NotExistingTableException))]
        public void TestWithOldValues()
        {
            SqlTableDependency<DataAnnotationTestSqlServer6Model> tableDependency = null;
            string naming = null;

            try
            {
                var mapper = new ModelToTableMapper<DataAnnotationTestSqlServer6Model>();
                mapper.AddMapping(c => c.Description, "Long Description");

                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer6Model>(ConnectionStringForTestUser, includeOldValues: true);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item2.Name);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item2.Description);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest07.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        [ExpectedException(typeof(NotExistingTableException))]
        public void Test()
        {
            SqlTableDependency<DataAnnotationTestSqlServer7Model> tableDependency = null;
            string naming = null;

            try
            {
                var mapper = new ModelToTableMapper<DataAnnotationTestSqlServer7Model>();
                mapper.AddMapping(c => c.Description, "Long Description");

                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer7Model>(ConnectionStringForTestUser);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                Thread.Sleep(5000);

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Update.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest07.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        [ExpectedException(typeof(NotExistingTableException))]
        public void TestWithOldValues()
        {
            SqlTableDependency<DataAnnotationTestSqlServer7Model> tableDependency = null;
            string naming = null;

            try
            {
                var mapper = new ModelToTableMapper<DataAnnotationTestSqlServer7Model>();
                mapper.AddMapping(c => c.Description, "Long Description");

                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer7Model>(ConnectionStringForTestUser, includeOldValues: true);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                Thread.Sleep(5000);

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item2.Name);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item2.Description);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest08.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        [ExpectedException(typeof(NoMatchBetweenModelAndTableColumns))]
        public void Test()
        {
            SqlTableDependency<DataAnnotationTestSqlServer8Model> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer8Model>(ConnectionStringForTestUser);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.NameNotExist, _checkValues[ChangeType.Insert.ToString()].Item1.NameNotExist);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.DescriptionNotExist, _checkValues[ChangeType.Insert.ToString()].Item1.DescriptionNotExist);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.NameNotExist, _checkValues[ChangeType.Update.ToString()].Item1.NameNotExist);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.DescriptionNotExist, _checkValues[ChangeType.Update.ToString()].Item1.DescriptionNotExist);
            replacedert.IsNull(_checkValuesOld[ChangeType.Update.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.NameNotExist, _checkValues[ChangeType.Delete.ToString()].Item1.NameNotExist);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.DescriptionNotExist, _checkValues[ChangeType.Delete.ToString()].Item1.DescriptionNotExist);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest08.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        [ExpectedException(typeof(NoMatchBetweenModelAndTableColumns))]
        public void TestWithOldValues()
        {
            SqlTableDependency<DataAnnotationTestSqlServer8Model> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer8Model>(ConnectionStringForTestUser, includeOldValues: true);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.NameNotExist, _checkValues[ChangeType.Insert.ToString()].Item1.NameNotExist);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.DescriptionNotExist, _checkValues[ChangeType.Insert.ToString()].Item1.DescriptionNotExist);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.NameNotExist, _checkValues[ChangeType.Update.ToString()].Item1.NameNotExist);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.DescriptionNotExist, _checkValues[ChangeType.Update.ToString()].Item1.DescriptionNotExist);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.NameNotExist, _checkValues[ChangeType.Insert.ToString()].Item2.NameNotExist);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.DescriptionNotExist, _checkValues[ChangeType.Insert.ToString()].Item2.DescriptionNotExist);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.NameNotExist, _checkValues[ChangeType.Delete.ToString()].Item1.NameNotExist);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.DescriptionNotExist, _checkValues[ChangeType.Delete.ToString()].Item1.DescriptionNotExist);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest09.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<DataAnnotationTestSqlServer9Model> tableDependency = null;
            string naming;

            try
            {
                var mapper = new ModelToTableMapper<DataAnnotationTestSqlServer9Model>();
                mapper.AddMapping(c => c.Description, "Long Description");

                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer9Model>(
                    ConnectionStringForTestUser,
                    tableName: TableName,
                    schemaName: SchemaName,
                    mapper: mapper);

                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                Thread.Sleep(5000);

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Update.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest09.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void TestWithOldValues()
        {
            SqlTableDependency<DataAnnotationTestSqlServer9Model> tableDependency = null;
            string naming;

            try
            {
                var mapper = new ModelToTableMapper<DataAnnotationTestSqlServer9Model>();
                mapper.AddMapping(c => c.Description, "Long Description");

                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer9Model>(
                    ConnectionStringForTestUser,
                    includeOldValues: true,
                    tableName: TableName,
                    schemaName: SchemaName,
                    mapper: mapper);

                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                Thread.Sleep(5000);

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item2.Name);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item2.Description);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest10.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<DataAnnotationTestSqlServer10Model> tableDependency = null;
            string naming;

            try
            {
                var mapper = new ModelToTableMapper<DataAnnotationTestSqlServer10Model>();
                mapper.AddMapping(c => c.Description, "Long Description");

                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer10Model>(
                    ConnectionStringForTestUser, 
                    includeOldValues: false,
                    schemaName: ScemaName, 
                    mapper: mapper);

                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                Thread.Sleep(5000);

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 5 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Update.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest10.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void TestWithOldValues()
        {
            SqlTableDependency<DataAnnotationTestSqlServer10Model> tableDependency = null;
            string naming;

            try
            {
                var mapper = new ModelToTableMapper<DataAnnotationTestSqlServer10Model>();
                mapper.AddMapping(c => c.Description, "Long Description");

                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer10Model>(
                    ConnectionStringForTestUser,
                    includeOldValues: true,
                    schemaName: ScemaName,
                    mapper: mapper);

                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                Thread.Sleep(5000);

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item2.Name);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item2.Description);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DatabaseObjectAutoCleanUpTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void TestInsertAfterStop()
        {
            var mapper = new ModelToTableMapper<DatabaseObjectCleanUpTestSqlServerModel>();
            mapper.AddMapping(c => c.Name, "FIRST name").AddMapping(c => c.Surname, "Second Name");

            var tableDependency = new SqlTableDependency<DatabaseObjectCleanUpTestSqlServerModel>(
                ConnectionStringForTestUser,
                includeOldValues: true,
                tableName: TableName,
                mapper: mapper);

            tableDependency.OnChanged += (sender, e) => { };
            tableDependency.Start();
            var dbObjectsNaming = tableDependency.DataBaseObjectsNamingConvention;

            var t = new Task(BigModifyTableContent);
            t.Start();
            Thread.Sleep(1000 * 15 * 1);

            tableDependency.Stop();

            SmalModifyTableContent();

            Thread.Sleep(1 * 15 * 1000);
            replacedert.IsTrue(base.AreAllDbObjectDisposed(dbObjectsNaming));
            replacedert.IsTrue(base.CountConversationEndpoints(dbObjectsNaming) == 0);
        }

19 Source : DatabaseObjectAutoCleanUpTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void TestCleanUpAfter2InsertsTest()
        {
            var mapper = new ModelToTableMapper<DatabaseObjectCleanUpTestSqlServerModel>();
            mapper.AddMapping(c => c.Name, "First Name").AddMapping(c => c.Surname, "Second Name");

            var tableDependency = new SqlTableDependencyTest<DatabaseObjectCleanUpTestSqlServerModel>(
                ConnectionStringForTestUser,
                includeOldValues: true,
                tableName: TableName,
                mapper: mapper);

            tableDependency.OnChanged += (sender, e) => { }; 
            tableDependency.Start();
            var dbObjectsNaming = tableDependency.DataBaseObjectsNamingConvention;

            Thread.Sleep(500);

            tableDependency.Stop();

            var t = new Task(ModifyTableContent);
            t.Start();

            Thread.Sleep(1000 * 15 * 1);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(dbObjectsNaming));
            replacedert.IsTrue(base.CountConversationEndpoints(dbObjectsNaming) == 0);
        }

19 Source : DateTypeTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<DateTypeTestModel> tableDependency = null;

            try
            {
                tableDependency = new SqlTableDependency<DateTypeTestModel>(ConnectionStringForTestUser);
                tableDependency.OnChanged += this.TableDependency_Changed;
                tableDependency.Start();             

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.DateColumn, _checkValues[ChangeType.Insert.ToString()].Item1.DateColumn);
            replacedert.IsNull(_checkValues[ChangeType.Insert.ToString()].Item2.DatetimeColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Datetime2Column, _checkValues[ChangeType.Insert.ToString()].Item1.Datetime2Column);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.DatetimeoffsetColumn, _checkValues[ChangeType.Insert.ToString()].Item1.DatetimeoffsetColumn);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.IsNull(_checkValues[ChangeType.Update.ToString()].Item2.DateColumn);
            var date1 = _checkValues[ChangeType.Update.ToString()].Item1.DatetimeColumn.GetValueOrDefault().AddMilliseconds(-_checkValues[ChangeType.Update.ToString()].Item1.DatetimeColumn.GetValueOrDefault().Millisecond);
            var date2 = _checkValues[ChangeType.Update.ToString()].Item2.DatetimeColumn.GetValueOrDefault().AddMilliseconds(-_checkValues[ChangeType.Update.ToString()].Item2.DatetimeColumn.GetValueOrDefault().Millisecond);
            replacedert.AreEqual(date1.ToString("yyyyMMddhhmm"), date2.ToString("yyyyMMddhhmm"));
            replacedert.IsNull(_checkValues[ChangeType.Update.ToString()].Item2.Datetime2Column);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.DatetimeoffsetColumn, _checkValues[ChangeType.Update.ToString()].Item1.DatetimeoffsetColumn);
            replacedert.IsNull(_checkValuesOld[ChangeType.Update.ToString()]);

            replacedert.IsNull(_checkValues[ChangeType.Delete.ToString()].Item2.DateColumn);
            date1 = _checkValues[ChangeType.Update.ToString()].Item1.DatetimeColumn.GetValueOrDefault().AddMilliseconds(-_checkValues[ChangeType.Update.ToString()].Item1.DatetimeColumn.GetValueOrDefault().Millisecond);
            date2 = _checkValues[ChangeType.Update.ToString()].Item2.DatetimeColumn.GetValueOrDefault().AddMilliseconds(-_checkValues[ChangeType.Update.ToString()].Item2.DatetimeColumn.GetValueOrDefault().Millisecond);
            replacedert.AreEqual(date1.ToString("yyyyMMddhhmm"), date2.ToString("yyyyMMddhhmm"));
            replacedert.IsNull(_checkValues[ChangeType.Delete.ToString()].Item2.Datetime2Column);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.DatetimeoffsetColumn.GetValueOrDefault().ToString("yyyyMMddhhmm"), _checkValues[ChangeType.Delete.ToString()].Item1.DatetimeoffsetColumn.GetValueOrDefault().ToString("yyyyMMddhhmm"));
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(tableDependency.DataBaseObjectsNamingConvention));
            replacedert.IsTrue(base.CountConversationEndpoints(tableDependency.DataBaseObjectsNamingConvention) == 0);
        }

19 Source : EndpointsStatusTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            bool startReceivingMessages = false;

            var tableDependency = new SqlTableDependency<EndpointsStatusModel>(ConnectionStringForTestUser, includeOldValues: true);
            tableDependency.OnChanged += (o, args) => { startReceivingMessages = true; };
            tableDependency.Start();
            var naming = tableDependency.DataBaseObjectsNamingConvention;

            replacedert.IsTrue(this.IsSenderEndpointInStatus(naming, ConversationEndpointState.SO));
            replacedert.IsTrue(this.IsReceiverEndpointInStatus(naming, null));

            var t = new Task(InsertRecord);
            t.Start();
            while (startReceivingMessages == false) Thread.Sleep(1000 * 1 * 1);

            replacedert.IsTrue(this.IsSenderEndpointInStatus(naming, ConversationEndpointState.CO));
            replacedert.IsTrue(this.IsReceiverEndpointInStatus(naming, ConversationEndpointState.CO));

            tableDependency.Stop();

            Thread.Sleep(1000 * 15 * 1);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : BigIntDecimalAndFloatTypesTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<BigIntDecimalAndFloatTypesTestSqlServerModel> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<BigIntDecimalAndFloatTypesTestSqlServerModel>(ConnectionStringForTestUser);
                tableDependency.OnChanged += this.TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.BigintColumn, _checkValues[ChangeType.Insert.ToString()].Item1.BigintColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Decimal18Column, _checkValues[ChangeType.Insert.ToString()].Item1.Decimal18Column);
            replacedert.IsNull(_checkValues[ChangeType.Insert.ToString()].Item2.Decimal54Column);
            replacedert.IsNull(_checkValues[ChangeType.Insert.ToString()].Item2.FloatColumn);

            replacedert.IsNull(_checkValues[ChangeType.Update.ToString()].Item2.BigintColumn);
            replacedert.IsNull(_checkValues[ChangeType.Update.ToString()].Item2.Decimal18Column);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Decimal54Column, _checkValues[ChangeType.Update.ToString()].Item1.Decimal54Column);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.FloatColumn, _checkValues[ChangeType.Update.ToString()].Item1.FloatColumn);

            replacedert.IsNull(_checkValues[ChangeType.Delete.ToString()].Item2.BigintColumn);
            replacedert.IsNull(_checkValues[ChangeType.Delete.ToString()].Item2.Decimal18Column);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Decimal54Column, _checkValues[ChangeType.Delete.ToString()].Item1.Decimal54Column);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.FloatColumn, _checkValues[ChangeType.Delete.ToString()].Item1.FloatColumn);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : ComputedColumnTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void TestWithOldValues()
        {
            SqlTableDependency<ComputedColumnModel> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<ComputedColumnModel>(ConnectionStringForTestUser, includeOldValues: true);
                naming = tableDependency.DataBaseObjectsNamingConvention;
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Name, CheckValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.BirthDate, CheckValues[ChangeType.Insert.ToString()].Item1.BirthDate);
            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.CalculatedAge, CheckValues[ChangeType.Insert.ToString()].Item1.CalculatedAge);
            replacedert.IsNull(CheckValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Name, CheckValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.BirthDate, CheckValues[ChangeType.Update.ToString()].Item1.BirthDate);
            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.CalculatedAge, CheckValues[ChangeType.Update.ToString()].Item1.CalculatedAge);
            replacedert.AreEqual(CheckValuesOld[ChangeType.Update.ToString()].Item2.Name, CheckValues[ChangeType.Insert.ToString()].Item2.Name);
            replacedert.AreEqual(CheckValuesOld[ChangeType.Update.ToString()].Item2.BirthDate, CheckValues[ChangeType.Insert.ToString()].Item2.BirthDate);
            replacedert.AreEqual(CheckValuesOld[ChangeType.Update.ToString()].Item2.CalculatedAge, CheckValues[ChangeType.Insert.ToString()].Item2.CalculatedAge);
            
            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Name, CheckValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.BirthDate, CheckValues[ChangeType.Delete.ToString()].Item1.BirthDate);
            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.CalculatedAge, CheckValues[ChangeType.Delete.ToString()].Item1.CalculatedAge);
            replacedert.IsNull(CheckValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest04.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<DataAnnotationTestSqlServer4Model> tableDependency = null;
            string naming;

            var mapper = new ModelToTableMapper<DataAnnotationTestSqlServer4Model>();
            mapper.AddMapping(c => c.Description, "Long Description");

            try
            {
                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer4Model>(ConnectionStringForTestUser, tableName: TableName, mapper: mapper);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Update.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest04.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void TestWithOldValues()
        {
            SqlTableDependency<DataAnnotationTestSqlServer4Model> tableDependency = null;
            string naming;

            var mapper = new ModelToTableMapper<DataAnnotationTestSqlServer4Model>();
            mapper.AddMapping(c => c.Description, "Long Description");

            try
            {
                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer4Model>(ConnectionStringForTestUser, includeOldValues: true, tableName: TableName, mapper: mapper);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item2.Name);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item2.Description);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest05.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<DataAnnotationTestSqlServer5Model> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer5Model>(ConnectionStringForTestUser, tableName: TableName);
                tableDependency.OnChanged += TableDependency_Changed;                
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Update.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : DataAnnotationTest05.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void TestWithOldValues()
        {
            SqlTableDependency<DataAnnotationTestSqlServer5Model> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<DataAnnotationTestSqlServer5Model>(ConnectionStringForTestUser, includeOldValues: true, tableName: TableName);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Update.ToString()].Item1.Description);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item2.Name);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Description, _checkValues[ChangeType.Insert.ToString()].Item2.Description);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Description, _checkValues[ChangeType.Delete.ToString()].Item1.Description);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : Issue66Test.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test1()
        {
            SqlTableDependency<Issue66Model1> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<Issue66Model1>(ConnectionStringForTestUser, includeOldValues: true, tableName: TableName + "1");
                tableDependency.OnChanged += this.TableDependency_Changed1;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent1);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(CheckValues1[ChangeType.Insert.ToString()][0].Id, 1);
            replacedert.AreEqual(CheckValues1[ChangeType.Insert.ToString()][0].Name, "CHRISTIAN");
            replacedert.AreEqual(CheckValues1[ChangeType.Insert.ToString()][0].City, "LAVENA PONTE TRESA");
            replacedert.AreEqual(CheckValues1[ChangeType.Insert.ToString()][1].Id, 2);
            replacedert.AreEqual(CheckValues1[ChangeType.Insert.ToString()][1].Name, "VALENTINA");
            replacedert.AreEqual(CheckValues1[ChangeType.Insert.ToString()][1].City, "LAVENA PONTE TRESA");

            replacedert.AreEqual(CheckValues1[ChangeType.Update.ToString()][0].City, "BAAR");
            replacedert.AreEqual(CheckValues1[ChangeType.Update.ToString()][1].City, "BAAR");
            replacedert.AreEqual(CheckValuesOld1[ChangeType.Update.ToString()][0].City, "LAVENA PONTE TRESA");
            replacedert.AreEqual(CheckValuesOld1[ChangeType.Update.ToString()][1].City, "LAVENA PONTE TRESA");

            replacedert.AreEqual(CheckValues1[ChangeType.Delete.ToString()][0].Name, "christian");
            replacedert.AreEqual(CheckValues1[ChangeType.Delete.ToString()][0].City, "BAAR");
            replacedert.AreEqual(CheckValues1[ChangeType.Delete.ToString()][1].Name, "valentina");
            replacedert.AreEqual(CheckValues1[ChangeType.Delete.ToString()][1].City, "BAAR");

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : Issue66Test.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test2()
        {
            SqlTableDependency<Issue66Model2> tableDependency = null;
            string naming;

            var mapper = new ModelToTableMapper<Issue66Model2>();
            mapper.AddMapping(c => c.Surname, "Second Name");

            var updateOf = new UpdateOfModel<Issue66Model2>();
            updateOf.Add(i => i.Surname);
            updateOf.Add(i => i.City);

            try
            {
                tableDependency = new SqlTableDependency<Issue66Model2>(ConnectionStringForTestUser, includeOldValues: true, tableName: TableName + "2", mapper: mapper, updateOf: updateOf);
                tableDependency.OnChanged += this.TableDependency_Changed2;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent2);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()][0].Id, 1);
            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()][0].Name, "CHRISTIAN");
            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()][0].City, "LAVENA PONTE TRESA");
            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()][1].Id, 2);
            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()][1].Name, "VALENTINA");
            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()][1].City, "LAVENA PONTE TRESA");

            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()][0].City, "BAAR");
            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()][1].City, "BAAR");
            replacedert.AreEqual(CheckValuesOld2[ChangeType.Update.ToString()][0].City, "LAVENA PONTE TRESA");
            replacedert.AreEqual(CheckValuesOld2[ChangeType.Update.ToString()][1].City, "LAVENA PONTE TRESA");

            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][0].Surname, "del bianco");
            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][0].Name, "christian");
            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][0].City, "BAAR");
            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][1].Surname, "del bianco");
            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][1].Name, "valentina");
            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][1].City, "BAAR");

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : Issue66Test.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test3()
        {
            SqlTableDependency<Issue66Model2> tableDependency = null;
            string naming;

            var mapper = new ModelToTableMapper<Issue66Model2>();
            mapper.AddMapping(c => c.Surname, "Second Name");

            try
            {
                tableDependency = new SqlTableDependency<Issue66Model2>(ConnectionStringForTestUser, includeOldValues: true, tableName: TableName + "2", mapper: mapper);
                tableDependency.OnChanged += this.TableDependency_Changed2;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent2);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()][0].Id, 1);
            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()][0].Name, "CHRISTIAN");
            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()][0].City, "LAVENA PONTE TRESA");
            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()][1].Id, 2);
            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()][1].Name, "VALENTINA");
            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()][1].City, "LAVENA PONTE TRESA");

            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()][0].City, "BAAR");
            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()][1].City, "BAAR");
            replacedert.AreEqual(CheckValuesOld2[ChangeType.Update.ToString()][0].City, "LAVENA PONTE TRESA");
            replacedert.AreEqual(CheckValuesOld2[ChangeType.Update.ToString()][1].City, "LAVENA PONTE TRESA");

            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][0].Surname, "del bianco");
            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][0].Name, "christian");
            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][0].City, "BAAR");
            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][1].Surname, "del bianco");
            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][1].Name, "valentina");
            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][1].City, "BAAR");

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : Issue66Test.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test4()
        {
            SqlTableDependency<Issue66Model1> tableDependency = null;
            string naming;

            var updateOf = new UpdateOfModel<Issue66Model1>();
            updateOf.Add(i => i.Name);
            updateOf.Add(i => i.City);

            try
            {
                tableDependency = new SqlTableDependency<Issue66Model1>(ConnectionStringForTestUser, includeOldValues: true, tableName: TableName + "1", updateOf: updateOf);
                tableDependency.OnChanged += this.TableDependency_Changed1;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent1);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(CheckValues1[ChangeType.Insert.ToString()][0].Id, 1);
            replacedert.AreEqual(CheckValues1[ChangeType.Insert.ToString()][0].Name, "CHRISTIAN");
            replacedert.AreEqual(CheckValues1[ChangeType.Insert.ToString()][0].City, "LAVENA PONTE TRESA");
            replacedert.AreEqual(CheckValues1[ChangeType.Insert.ToString()][1].Id, 2);
            replacedert.AreEqual(CheckValues1[ChangeType.Insert.ToString()][1].Name, "VALENTINA");
            replacedert.AreEqual(CheckValues1[ChangeType.Insert.ToString()][1].City, "LAVENA PONTE TRESA");

            replacedert.AreEqual(CheckValues1[ChangeType.Update.ToString()][0].City, "BAAR");
            replacedert.AreEqual(CheckValues1[ChangeType.Update.ToString()][1].City, "BAAR");
            replacedert.AreEqual(CheckValuesOld1[ChangeType.Update.ToString()][0].City, "LAVENA PONTE TRESA");
            replacedert.AreEqual(CheckValuesOld1[ChangeType.Update.ToString()][1].City, "LAVENA PONTE TRESA");

            replacedert.AreEqual(CheckValues1[ChangeType.Delete.ToString()][0].Name, "christian");
            replacedert.AreEqual(CheckValues1[ChangeType.Delete.ToString()][0].City, "BAAR");
            replacedert.AreEqual(CheckValues1[ChangeType.Delete.ToString()][1].Name, "valentina");
            replacedert.AreEqual(CheckValues1[ChangeType.Delete.ToString()][1].City, "BAAR");

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : Issue66Test.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test5()
        {
            SqlTableDependency<Issue66Model2> tableDependency = null;
            string naming;

            var mapper = new ModelToTableMapper<Issue66Model2>();
            mapper.AddMapping(c => c.Surname, "Second Name");

            Expression<Func<Issue66Model2, bool>> expression = p => p.Id == 1 && p.Surname == "DEL BIANCO";
            ITableDependencyFilter whereCondition = new SqlTableDependencyFilter<Issue66Model2>(expression, mapper);

            var updateOf = new UpdateOfModel<Issue66Model2>();
            updateOf.Add(i => i.Surname);
            updateOf.Add(i => i.City);

            try
            {
                tableDependency = new SqlTableDependency<Issue66Model2>(
                    ConnectionStringForTestUser, 
                    includeOldValues: true, 
                    tableName: TableName + "2", 
                    mapper: mapper, 
                    updateOf: updateOf,
                    filter: whereCondition);

                tableDependency.OnChanged += this.TableDependency_Changed2;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent5);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()].Count, 0);

            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()].Count, 1);

            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()][0].Id, 1);
            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()][0].Surname, "DEL BIANCO");
            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()][0].Name, "CHRISTIAN");
            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()][0].City, "BAAR");
            replacedert.AreEqual(CheckValuesOld2[ChangeType.Update.ToString()][0].Id, 1);
            replacedert.AreEqual(CheckValuesOld2[ChangeType.Update.ToString()][0].Surname, "DELBIANCO");
            replacedert.AreEqual(CheckValuesOld2[ChangeType.Update.ToString()][0].Name, "CHRISTIAN");
            replacedert.AreEqual(CheckValuesOld2[ChangeType.Update.ToString()][0].City, "LAVENA PONTE TRESA");

            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()].Count, 1);

            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][0].Surname, "DEL BIANCO");
            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][0].Name, "christian");
            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()][0].City, "BAAR");

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : Issue66Test.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test6()
        {
            SqlTableDependency<Issue66Model2> tableDependency = null;
            string naming;

            var mapper = new ModelToTableMapper<Issue66Model2>();
            mapper.AddMapping(c => c.Surname, "Second Name");

            Expression<Func<Issue66Model2, bool>> expression = p => p.Id == 1 && p.Surname == "DEL BIANCO";
            ITableDependencyFilter whereCondition = new SqlTableDependencyFilter<Issue66Model2>(expression, mapper);

            var updateOf = new UpdateOfModel<Issue66Model2>();
            updateOf.Add(i => i.Surname);
            updateOf.Add(i => i.City);

            try
            {
                tableDependency = new SqlTableDependency<Issue66Model2>(
                    ConnectionStringForTestUser,
                    includeOldValues: true,
                    tableName: TableName + "2",
                    mapper: mapper,
                    updateOf: updateOf,
                    notifyOn: DmlTriggerType.Update,
                    filter: whereCondition);

                tableDependency.OnChanged += this.TableDependency_Changed2;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent5);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(CheckValues2[ChangeType.Insert.ToString()].Count, 0);

            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()].Count, 1);

            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()][0].Id, 1);
            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()][0].Surname, "DEL BIANCO");
            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()][0].Name, "CHRISTIAN");
            replacedert.AreEqual(CheckValues2[ChangeType.Update.ToString()][0].City, "BAAR");
            replacedert.AreEqual(CheckValuesOld2[ChangeType.Update.ToString()][0].Id, 1);
            replacedert.AreEqual(CheckValuesOld2[ChangeType.Update.ToString()][0].Surname, "DELBIANCO");
            replacedert.AreEqual(CheckValuesOld2[ChangeType.Update.ToString()][0].Name, "CHRISTIAN");
            replacedert.AreEqual(CheckValuesOld2[ChangeType.Update.ToString()][0].City, "LAVENA PONTE TRESA");

            replacedert.AreEqual(CheckValues2[ChangeType.Delete.ToString()].Count, 0);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : MargeTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<MargeTestSqlServerModel> tableDependency = null;

            try
            {
                tableDependency = new SqlTableDependency<MargeTestSqlServerModel>(ConnectionStringForTestUser, tableName: TargetTableName);
                tableDependency.OnChanged += this.TableDependency_Changed;
                tableDependency.OnError += this.TableDependency_OnError;
                tableDependency.Start();

                Thread.Sleep(10000);

                var t = new Task(MergeOperation);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(this._insertedValues.Quanreplacedy, 100);
            replacedert.AreEqual(this._modifiedValues.Quanreplacedy, 200);
            replacedert.AreEqual(this._deletedValues.Quanreplacedy, 0);
        }

19 Source : MassiveChangesInSingleCommandTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<MreplacediveChangesInSingleCommandModel> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<MreplacediveChangesInSingleCommandModel>(ConnectionStringForTestUser);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t1 = new Task(ModifyTableContent1);
                var t2 = new Task(ModifyTableContent2);

                t1.Start();
                t2.Start();

                Thread.Sleep(1000 * 10 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.IsTrue(_checkValues[ChangeType.Insert.ToString()].All(m => (m.Id == 1 || m.Id == 3) && (m.Name == "Luciano Bruschi" || m.Name == "Dina Bruschi")));
            replacedert.IsTrue(_checkValues[ChangeType.Insert.ToString()].Count == 20);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.IsTrue(_checkValues[ChangeType.Update.ToString()].All(m => (m.Id == 2 || m.Id == 4) && (m.Name == "Ceccarelli Velia" || m.Name == "Ismano Del Bianco")));
            replacedert.IsTrue(_checkValues[ChangeType.Update.ToString()].Count == 20);
            replacedert.IsNull(_checkValuesOld[ChangeType.Update.ToString()]);

            replacedert.IsTrue(_checkValues[ChangeType.Delete.ToString()].All(m => (m.Id == 2 || m.Id == 4) && (m.Name == "Ceccarelli Velia" || m.Name == "Ismano Del Bianco")));
            replacedert.IsTrue(_checkValues[ChangeType.Delete.ToString()].Count == 20);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : MassiveChangesInSingleCommandTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void TestWithOldValues()
        {
            SqlTableDependency<MreplacediveChangesInSingleCommandModel> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<MreplacediveChangesInSingleCommandModel>(ConnectionStringForTestUser, includeOldValues: true);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t1 = new Task(ModifyTableContent1);
                var t2 = new Task(ModifyTableContent2);

                t1.Start();
                t2.Start();

                Thread.Sleep(1000 * 10 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.IsTrue(_checkValues[ChangeType.Insert.ToString()].All(m => (m.Id == 1 || m.Id == 3) && (m.Name == "Luciano Bruschi" || m.Name == "Dina Bruschi")));
            replacedert.IsTrue(_checkValues[ChangeType.Insert.ToString()].Count == 20);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.IsTrue(_checkValues[ChangeType.Update.ToString()].All(m => (m.Id == 2 || m.Id == 4) && (m.Name == "Ceccarelli Velia" || m.Name == "Ismano Del Bianco")));
            replacedert.IsTrue(_checkValues[ChangeType.Update.ToString()].Count == 20);
            replacedert.IsTrue(_checkValuesOld[ChangeType.Update.ToString()].All(m => (m.Id == 1 || m.Id == 3) && (m.Name == "Luciano Bruschi" || m.Name == "Dina Bruschi")));
            replacedert.IsTrue(_checkValuesOld[ChangeType.Update.ToString()].Count == 20);

            replacedert.IsTrue(_checkValues[ChangeType.Delete.ToString()].All(m => (m.Id == 2 || m.Id == 4) && (m.Name == "Ceccarelli Velia" || m.Name == "Ismano Del Bianco")));
            replacedert.IsTrue(_checkValues[ChangeType.Delete.ToString()].Count == 20);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);


            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : EnumTestSqlServer1.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<EnumTestSqlServerModel1> tableDependency = null;

            try
            {
                tableDependency = new SqlTableDependency<EnumTestSqlServerModel1>(ConnectionStringForTestUser, TableName);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Name, CheckValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Surname, CheckValues[ChangeType.Insert.ToString()].Item1.Surname);
            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.Tipo, CheckValues[ChangeType.Insert.ToString()].Item1.Tipo);

            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Name, CheckValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Surname, CheckValues[ChangeType.Update.ToString()].Item1.Surname);
            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.Tipo, CheckValues[ChangeType.Update.ToString()].Item1.Tipo);

            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Name, CheckValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Surname, CheckValues[ChangeType.Delete.ToString()].Item1.Surname);
            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.Tipo, CheckValues[ChangeType.Delete.ToString()].Item1.Tipo);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(tableDependency.DataBaseObjectsNamingConvention));
            replacedert.IsTrue(base.CountConversationEndpoints(tableDependency.DataBaseObjectsNamingConvention) == 0);
        }

19 Source : EnumTestSqlServer2.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<EnumTestSqlServerModel2> tableDependency = null;

            try
            {
                tableDependency = new SqlTableDependency<EnumTestSqlServerModel2>(ConnectionStringForTestUser, TableName);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.TesterName, CheckValues[ChangeType.Insert.ToString()].Item1.TesterName);
            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.TestStatus, CheckValues[ChangeType.Insert.ToString()].Item1.TestStatus);
            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.TestType, CheckValues[ChangeType.Insert.ToString()].Item1.TestType);
            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Item2.ErrorMessage, CheckValues[ChangeType.Insert.ToString()].Item1.ErrorMessage);

            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.TesterName, CheckValues[ChangeType.Update.ToString()].Item1.TesterName);
            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.TestType, CheckValues[ChangeType.Update.ToString()].Item1.TestType);
            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Item2.TestStatus, CheckValues[ChangeType.Update.ToString()].Item1.TestStatus);
            replacedert.IsNull(CheckValues[ChangeType.Update.ToString()].Item2.ErrorMessage);

            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.TesterName, CheckValues[ChangeType.Delete.ToString()].Item1.TesterName);
            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.TestType, CheckValues[ChangeType.Delete.ToString()].Item1.TestType);
            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Item2.TestStatus, CheckValues[ChangeType.Delete.ToString()].Item1.TestStatus);
            replacedert.IsNull(CheckValues[ChangeType.Delete.ToString()].Item2.ErrorMessage);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(tableDependency.DataBaseObjectsNamingConvention));
            replacedert.IsTrue(base.CountConversationEndpoints(tableDependency.DataBaseObjectsNamingConvention) == 0);
        }

19 Source : EventForAllColumnsTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<EventForAllColumnsTestSqlServerModel> tableDependency = null;

            try
            {
                var mapper = new ModelToTableMapper<EventForAllColumnsTestSqlServerModel>();
                mapper.AddMapping(c => c.Name, "FIRST name").AddMapping(c => c.Surname, "Second Name");

                tableDependency = new SqlTableDependency<EventForAllColumnsTestSqlServerModel>(ConnectionStringForTestUser, tableName: TableName, mapper: mapper);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Surname, _checkValues[ChangeType.Insert.ToString()].Item1.Surname);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Surname, _checkValues[ChangeType.Update.ToString()].Item1.Surname);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Surname, _checkValues[ChangeType.Delete.ToString()].Item1.Surname);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(tableDependency.DataBaseObjectsNamingConvention));
            replacedert.IsTrue(base.CountConversationEndpoints(tableDependency.DataBaseObjectsNamingConvention) == 0);
        }

19 Source : EventForAllColumnsTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void TestWithOldValue()
        {
            SqlTableDependency<EventForAllColumnsTestSqlServerModel> tableDependency = null;

            try
            {
                var mapper = new ModelToTableMapper<EventForAllColumnsTestSqlServerModel>();
                mapper.AddMapping(c => c.Name, "FIRST name").AddMapping(c => c.Surname, "Second Name");

                tableDependency = new SqlTableDependency<EventForAllColumnsTestSqlServerModel>(
                    ConnectionStringForTestUser, 
                    includeOldValues: true,
                    tableName: TableName, 
                    mapper: mapper);

                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Surname, _checkValues[ChangeType.Insert.ToString()].Item1.Surname);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Update.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Surname, _checkValues[ChangeType.Update.ToString()].Item1.Surname);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item2.Name);
            replacedert.AreEqual(_checkValuesOld[ChangeType.Update.ToString()].Item2.Surname, _checkValues[ChangeType.Insert.ToString()].Item2.Surname);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Surname, _checkValues[ChangeType.Delete.ToString()].Item1.Surname);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(tableDependency.DataBaseObjectsNamingConvention));
            replacedert.IsTrue(base.CountConversationEndpoints(tableDependency.DataBaseObjectsNamingConvention) == 0);
        }

19 Source : EventForSpecificColumnsTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<EventForSpecificColumnsTestSqlServerModel> tableDependency = null;
            string naming;

            try
            {
                var mapper = new ModelToTableMapper<EventForSpecificColumnsTestSqlServerModel>();
                mapper.AddMapping(c => c.Name, "FIRST name").AddMapping(c => c.Surname, "Second Name");

                var updateOf = new UpdateOfModel<EventForSpecificColumnsTestSqlServerModel>();
                updateOf.Add(i => i.Surname);

                tableDependency = new SqlTableDependency<EventForSpecificColumnsTestSqlServerModel>(
                    ConnectionStringForTestUser, 
                    tableName: TableName, 
                    mapper: mapper, 
                    updateOf: updateOf);

                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 2);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Surname, _checkValues[ChangeType.Insert.ToString()].Item1.Surname);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Surname, _checkValues[ChangeType.Delete.ToString()].Item1.Surname);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming)== 0);
        }

19 Source : EventForSpecificColumnsTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void TestWithOldValues()
        {
            SqlTableDependency<EventForSpecificColumnsTestSqlServerModel> tableDependency = null;
            string naming;

            try
            {
                var mapper = new ModelToTableMapper<EventForSpecificColumnsTestSqlServerModel>();
                mapper.AddMapping(c => c.Name, "FIRST name").AddMapping(c => c.Surname, "Second Name");

                var updateOf = new UpdateOfModel<EventForSpecificColumnsTestSqlServerModel>();
                updateOf.Add(i => i.Surname);

                tableDependency = new SqlTableDependency<EventForSpecificColumnsTestSqlServerModel>(
                    ConnectionStringForTestUser,
                    includeOldValues: true,
                    tableName: TableName,
                    mapper: mapper,
                    updateOf: updateOf);

                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 2);

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Name, _checkValues[ChangeType.Insert.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Surname, _checkValues[ChangeType.Insert.ToString()].Item1.Surname);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Name, _checkValues[ChangeType.Delete.ToString()].Item1.Name);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Surname, _checkValues[ChangeType.Delete.ToString()].Item1.Surname);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : MassiveChangesTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<MreplacediveChangesModel> tableDependency = null;
            string naming = null;

            try
            {
                tableDependency = new SqlTableDependency<MreplacediveChangesModel>(ConnectionStringForTestUser);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();

                while (Done == false) Thread.Sleep(1000 * 30 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.IsTrue(CheckValues[ChangeType.Insert.ToString()].All(m => m.Id == 1 && m.Name == "Luciano Bruschi"));
            replacedert.IsTrue(CheckValues[ChangeType.Insert.ToString()].Count == ChangesNumber);
            replacedert.IsTrue(CheckValues[ChangeType.Update.ToString()].All(m => m.Id == 2 && m.Name == "Ceccarelli Velia"));
            replacedert.IsTrue(CheckValues[ChangeType.Update.ToString()].Count == ChangesNumber);
            replacedert.IsTrue(CheckValues[ChangeType.Delete.ToString()].All(m => m.Id == 2 && m.Name == "Ceccarelli Velia"));
            replacedert.IsTrue(CheckValues[ChangeType.Delete.ToString()].Count == ChangesNumber);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

19 Source : ModelWithAnnotationUsedWithCunstructorParameterTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        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>(ConnectionStringForTestUser, tableName: TableName, mapper: mapper, updateOf: updateOf);
                tableDependency.OnChanged += TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;
                
                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter, 3);

            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Name, "Pizza MERGHERITA");
            replacedert.AreEqual(CheckValues[ChangeType.Insert.ToString()].Infos, "Pizza MERGHERITA");

            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Name, "Pizza MERGHERITA");
            replacedert.AreEqual(CheckValues[ChangeType.Update.ToString()].Infos, "FUNGHI PORCINI");

            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Name, "Pizza");
            replacedert.AreEqual(CheckValues[ChangeType.Delete.ToString()].Infos, "FUNGHI PORCINI");

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming)== 0);
        }

19 Source : MultiDmlOperationsOrderTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void MultiInsertTest1()
        { 
            SqlTableDependency<MultiDmlOperationsOrderTestModel> tableDependency = null;

            try
            {
                tableDependency = new SqlTableDependency<MultiDmlOperationsOrderTestModel>(ConnectionStringForTestUser, tableName: TableName);
                tableDependency.OnChanged += this.TableDependency_Changed;
                tableDependency.OnError += this.TableDependency_OnError;
                tableDependency.Start();

                var t = new Task(MultiInsertOperation1);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(3, _checkValues.Count);
            replacedert.IsTrue(_checkValues[0].Id == 100);
            replacedert.IsTrue(_checkValues[1].Id == 200);
            replacedert.IsTrue(_checkValues[2].Id == 300);
        }

19 Source : MultiDmlOperationsOrderTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void MultiInsertTest2()
        {
            SqlTableDependency<MultiDmlOperationsOrderTestModel> tableDependency = null;

            try
            {
                tableDependency = new SqlTableDependency<MultiDmlOperationsOrderTestModel>(ConnectionStringForTestUser, tableName: TableName);
                tableDependency.OnChanged += this.TableDependency_Changed;
                tableDependency.OnError += this.TableDependency_OnError;
                tableDependency.Start();

                var t = new Task(MultiInsertOperation2);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(3, _checkValues.Count);
            replacedert.IsTrue(_checkValues[0].Letter == "a");
            replacedert.IsTrue(_checkValues[1].Letter == "b");
            replacedert.IsTrue(_checkValues[2].Letter == "c");
        }

19 Source : NoChangesDuringFirstThreeMinutesTest2.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<NoChangesDuringFirstThreeMinutesTestSqlServer2Model> tableDependency = null;
            string dataBaseObjectsNamingConvention = null;

            try
            {
                tableDependency = new SqlTableDependency<NoChangesDuringFirstThreeMinutesTestSqlServer2Model>(ConnectionStringForTestUser, includeOldValues: true);
                tableDependency.OnChanged += TableDependency_Changed1;
                tableDependency.Start();
                dataBaseObjectsNamingConvention = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent1);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);

                replacedert.AreEqual(_counter, 3);
                replacedert.AreEqual(_checkValues1[ChangeType.Insert.ToString()].Item2.Name, _checkValues1[ChangeType.Insert.ToString()].Item1.Name);
                replacedert.AreEqual(_checkValues1[ChangeType.Insert.ToString()].Item2.Surname, _checkValues1[ChangeType.Insert.ToString()].Item1.Surname);
                replacedert.AreEqual(_checkValues1[ChangeType.Update.ToString()].Item2.Name, _checkValues1[ChangeType.Update.ToString()].Item1.Name);
                replacedert.AreEqual(_checkValues1[ChangeType.Update.ToString()].Item2.Surname, _checkValues1[ChangeType.Update.ToString()].Item1.Surname);
                replacedert.AreEqual(_checkValues1[ChangeType.Delete.ToString()].Item2.Name, _checkValues1[ChangeType.Delete.ToString()].Item1.Name);
                replacedert.AreEqual(_checkValues1[ChangeType.Delete.ToString()].Item2.Surname, _checkValues1[ChangeType.Delete.ToString()].Item1.Surname);

                Thread.Sleep(7 * 10 * 1000);
                var f = new Task(ModifyTableContent2);
                f.Start();
                Thread.Sleep(1000 * 15 * 1);

                replacedert.AreEqual(_counter, 6);
                replacedert.AreEqual(_checkValues2[ChangeType.Insert.ToString()].Item2.Name, _checkValues2[ChangeType.Insert.ToString()].Item1.Name);
                replacedert.AreEqual(_checkValues2[ChangeType.Insert.ToString()].Item2.Surname, _checkValues2[ChangeType.Insert.ToString()].Item1.Surname);
                replacedert.AreEqual(_checkValues2[ChangeType.Update.ToString()].Item2.Name, _checkValues2[ChangeType.Update.ToString()].Item1.Name);
                replacedert.AreEqual(_checkValues2[ChangeType.Update.ToString()].Item2.Surname, _checkValues2[ChangeType.Update.ToString()].Item1.Surname);
                replacedert.AreEqual(_checkValues2[ChangeType.Delete.ToString()].Item2.Name, _checkValues2[ChangeType.Delete.ToString()].Item1.Name);
                replacedert.AreEqual(_checkValues2[ChangeType.Delete.ToString()].Item2.Surname, _checkValues2[ChangeType.Delete.ToString()].Item1.Surname);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            Thread.Sleep(5000);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(dataBaseObjectsNamingConvention));
            replacedert.IsTrue(base.CountConversationEndpoints(dataBaseObjectsNamingConvention) == 0);
        }

19 Source : NotificationOnlyWhenNewValueIsDifferentFromOldValueTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void UpdateOneInterestedColumn()
        {
            SqlTableDependency<NotificationOnlyWhenNewValueIsDifferentFromOldValueSqlServerModel> tableDependency = null;
            string naming;

            try
            {
                var mapper = new ModelToTableMapper<NotificationOnlyWhenNewValueIsDifferentFromOldValueSqlServerModel>();
                mapper.AddMapping(c => c.Name, "FIRST name").AddMapping(c => c.Surname, "Second NAME");

                tableDependency = new SqlTableDependency<NotificationOnlyWhenNewValueIsDifferentFromOldValueSqlServerModel>(ConnectionStringForTestUser, includeOldValues: true, tableName: TableName, mapper: mapper);
                tableDependency.OnChanged += TableDependency_Changed1;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent1);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter1, 2);
            replacedert.AreEqual(CheckValues1[0].Item2.Name, CheckValues1[0].Item1.Name);
            replacedert.AreEqual(CheckValues1[0].Item2.Surname, CheckValues1[0].Item1.Surname);
            replacedert.AreEqual(CheckValues1[1].Item2.Name, CheckValues1[1].Item1.Name);
            replacedert.AreEqual(CheckValues1[1].Item2.Surname, CheckValues1[1].Item1.Surname);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming)== 0);
        }

19 Source : NotificationOnlyWhenNewValueIsDifferentFromOldValueTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void UpdateTwoInterestedColumn()
        {
            SqlTableDependency<NotificationOnlyWhenNewValueIsDifferentFromOldValueSqlServerModel> tableDependency = null;
            string naming;

            try
            {
                var mapper = new ModelToTableMapper<NotificationOnlyWhenNewValueIsDifferentFromOldValueSqlServerModel>();
                mapper.AddMapping(c => c.Name, "FIRST name").AddMapping(c => c.Surname, "Second NAME");

                tableDependency = new SqlTableDependency<NotificationOnlyWhenNewValueIsDifferentFromOldValueSqlServerModel>(ConnectionStringForTestUser, includeOldValues: true, tableName: TableName, mapper: mapper);
                tableDependency.OnChanged += TableDependency_Changed2;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent2);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_counter2, 2);
            replacedert.AreEqual(CheckValues2[0].Item2.Name, CheckValues2[0].Item1.Name);
            replacedert.AreEqual(CheckValues2[0].Item2.Surname, CheckValues2[0].Item1.Surname);
            replacedert.AreEqual(CheckValues2[1].Item2.Name, CheckValues2[1].Item1.Name);
            replacedert.AreEqual(CheckValues2[1].Item2.Surname, CheckValues2[1].Item1.Surname);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming)== 0);
        }

19 Source : GuidSmallMoneyTypesTest.cs
with MIT License
from christiandelbianco

[TestCategory("SqlServer")]
        [TestMethod]
        public void Test()
        {
            SqlTableDependency<GuidSmallMoneyTypesModel> tableDependency = null;
            string naming;

            try
            {
                tableDependency = new SqlTableDependency<GuidSmallMoneyTypesModel>(ConnectionStringForTestUser, tableName: TableName);
                tableDependency.OnChanged += this.TableDependency_Changed;
                tableDependency.Start();
                naming = tableDependency.DataBaseObjectsNamingConvention;

                var t = new Task(ModifyTableContent);
                t.Start();
                Thread.Sleep(1000 * 15 * 1);
            }
            finally
            {
                tableDependency?.Dispose();
            }

            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.UniqueidentifierColumn, _checkValues[ChangeType.Insert.ToString()].Item1.UniqueidentifierColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.Time7Column, _checkValues[ChangeType.Insert.ToString()].Item1.Time7Column);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.TinyintColumn, _checkValues[ChangeType.Insert.ToString()].Item1.TinyintColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.SmalldatetimeColumn, _checkValues[ChangeType.Insert.ToString()].Item1.SmalldatetimeColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.SmallintColumn, _checkValues[ChangeType.Insert.ToString()].Item1.SmallintColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.MoneyColumn, _checkValues[ChangeType.Insert.ToString()].Item1.MoneyColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Insert.ToString()].Item2.SmallmoneyColumn, _checkValues[ChangeType.Insert.ToString()].Item1.SmallmoneyColumn);
            replacedert.IsNull(_checkValuesOld[ChangeType.Insert.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.SmallintColumn, _checkValues[ChangeType.Update.ToString()].Item1.SmallintColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.Time7Column, _checkValues[ChangeType.Update.ToString()].Item1.Time7Column);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.TinyintColumn, _checkValues[ChangeType.Update.ToString()].Item1.TinyintColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.SmalldatetimeColumn, _checkValues[ChangeType.Update.ToString()].Item1.SmalldatetimeColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.SmallintColumn, _checkValues[ChangeType.Update.ToString()].Item1.SmallintColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.MoneyColumn, _checkValues[ChangeType.Update.ToString()].Item1.MoneyColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Update.ToString()].Item2.SmallmoneyColumn, _checkValues[ChangeType.Update.ToString()].Item1.SmallmoneyColumn);
            replacedert.IsNull(_checkValuesOld[ChangeType.Update.ToString()]);

            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.SmallintColumn, _checkValues[ChangeType.Delete.ToString()].Item1.SmallintColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.Time7Column, _checkValues[ChangeType.Delete.ToString()].Item1.Time7Column);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.TinyintColumn, _checkValues[ChangeType.Delete.ToString()].Item1.TinyintColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.SmalldatetimeColumn, _checkValues[ChangeType.Delete.ToString()].Item1.SmalldatetimeColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.SmallintColumn, _checkValues[ChangeType.Delete.ToString()].Item1.SmallintColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.MoneyColumn, _checkValues[ChangeType.Delete.ToString()].Item1.MoneyColumn);
            replacedert.AreEqual(_checkValues[ChangeType.Delete.ToString()].Item2.SmallmoneyColumn, _checkValues[ChangeType.Delete.ToString()].Item1.SmallmoneyColumn);
            replacedert.IsNull(_checkValuesOld[ChangeType.Delete.ToString()]);

            replacedert.IsTrue(base.AreAllDbObjectDisposed(naming));
            replacedert.IsTrue(base.CountConversationEndpoints(naming) == 0);
        }

See More Examples