Fix test for some storages

- Correct low-level query for Firebird
- Right exception to expect for Firebird and Mysql

Author: alex-kulakov

Orm/Xtensive.Orm.Tests/Storage/FailedQueryAndDbCommandNotificationsTest.cs

@@ -1,6 +1,6 @@
-// Copyright (C) 2017 Xtensive LLC.
-// All rights reserved.
-// For conditions of distribution and use, see license.
+// Copyright (C) 2017-2021 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
 // Created by: Julian Mamokin
 // Created:    2017.02.08
 
@@ -38,75 +38,92 @@ public class FailedQueryAndDbCommandNotificationsTest : AutoBuildTest
     public void InvalidQueryTest()
     {
       Exception thrownException = null;
-      EventHandler<QueryEventArgs> invalidQueryHandler = (sender, args) => {thrownException = args.Exception;};
       using (var session = Domain.OpenSession()) {
-        session.Events.QueryExecuted += invalidQueryHandler;
-        using (session.OpenTransaction())
-          Assert.Throws<InvalidOperationException>(() => session.Query.All<TestModel>().Single(m => m.SomeStringField=="lol"));
-        session.Events.QueryExecuted -= invalidQueryHandler;
+        session.Events.QueryExecuted += InvalidQueryHandler;
+        using (session.OpenTransaction()) {
+          _ = Assert.Throws<InvalidOperationException>(() => session.Query.All<TestModel>().Single(m => m.SomeStringField == "lol"));
+        }
+        session.Events.QueryExecuted -= InvalidQueryHandler;
         Assert.IsNotNull(thrownException);
         Assert.AreSame(typeof (InvalidOperationException), thrownException.GetType());
       }
+
+      void InvalidQueryHandler(object sender, QueryEventArgs args)
+      {
+        thrownException = args.Exception;
+      }
     }
 
     [Test]
     public void ValidQueryTest()
     {
-      EventHandler<QueryEventArgs> validQueryHandler = (sender, args) => { Assert.IsNull(args.Exception); };
       using (var session = Domain.OpenSession()) {
-        session.Events.QueryExecuted += validQueryHandler;
+        session.Events.QueryExecuted += ValidQueryHandler;
         using (session.OpenTransaction()) 
           Assert.DoesNotThrow(() => session.Query.All<TestModel>().Single(m => m.SomeStringField=="string1"));
-        session.Events.QueryExecuted -= validQueryHandler;
+        session.Events.QueryExecuted -= ValidQueryHandler;
+      }
+
+      static void ValidQueryHandler(object sender, QueryEventArgs args)
+      {
+        Assert.IsNull(args.Exception);
       }
     }
 
     [Test]
     public void InvalidDbCommandTest()
     {
       Exception commandExecutedException = null;
-      EventHandler<DbCommandEventArgs> invalidDbCommandHandler = (sender, args) => { commandExecutedException = args.Exception; };
       using (var session = Domain.OpenSession()) {
         using (session.OpenTransaction()) {
-          new TestModel { SomeStringField = "wat", SomeDateTimeField = DateTime.Now, UniqueValue = 1 };
+          _ = new TestModel { SomeStringField = "wat", SomeDateTimeField = DateTime.Now, UniqueValue = 1 };
           var expectedException = GetUniqueConstraintViolationExceptionType();
-          session.Events.DbCommandExecuted += invalidDbCommandHandler;
-          Assert.Throws(expectedException, () => session.SaveChanges());
-          session.Events.DbCommandExecuted -= invalidDbCommandHandler;
+          session.Events.DbCommandExecuted += InvalidDbCommandHandler;
+          _ = Assert.Throws(expectedException, () => session.SaveChanges());
+          session.Events.DbCommandExecuted -= InvalidDbCommandHandler;
           Assert.NotNull(commandExecutedException);
           Assert.AreEqual(expectedException, commandExecutedException.GetType());
         }
       }
+
+      void InvalidDbCommandHandler(object sender, DbCommandEventArgs args)
+      {
+        commandExecutedException = args.Exception;
+      }
     }
 
     [Test]
     public void ValidDbCommandTest()
     {
-      EventHandler<DbCommandEventArgs> validDbCommandHandler = (sender, args) => { Assert.IsNull(args.Exception); };
       using (var session = Domain.OpenSession()) {
         using (session.OpenTransaction()) {
-          new TestModel { SomeStringField = "wat", SomeDateTimeField = DateTime.Now, UniqueValue = 3 };
-          new TestModel { SomeStringField = "dat", SomeDateTimeField = DateTime.Now, UniqueValue = 4 };
-          session.Events.DbCommandExecuted += validDbCommandHandler;
+          _ = new TestModel { SomeStringField = "wat", SomeDateTimeField = DateTime.Now, UniqueValue = 3 };
+          _ = new TestModel { SomeStringField = "dat", SomeDateTimeField = DateTime.Now, UniqueValue = 4 };
+          session.Events.DbCommandExecuted += ValidDbCommandHandler;
           Assert.DoesNotThrow(() => session.SaveChanges());
-          session.Events.DbCommandExecuted -= validDbCommandHandler;
+          session.Events.DbCommandExecuted -= ValidDbCommandHandler;
         }
       }
+
+      static void ValidDbCommandHandler(object sender, DbCommandEventArgs args)
+      {
+        Assert.IsNull(args.Exception);
+      }
     }
 
     protected override void PopulateData()
     {
       using(var session = Domain.OpenSession())
       using (var transaction = session.OpenTransaction()) {
-        new TestModel { SomeStringField = "string1", SomeDateTimeField = DateTime.Now, UniqueValue = 1 };
+        _ = new TestModel { SomeStringField = "string1", SomeDateTimeField = DateTime.Now, UniqueValue = 1 };
         transaction.Complete();
       }
     }
 
     protected override DomainConfiguration BuildConfiguration()
     {
       var configuration = base.BuildConfiguration();
-      configuration.Types.Register(typeof (TestModel).Assembly, typeof (TestModel).Namespace);
+      configuration.Types.Register(typeof(TestModel).Assembly, typeof(TestModel).Namespace);
       configuration.UpgradeMode = DomainUpgradeMode.Recreate;
       return configuration;
     }
@@ -115,12 +132,10 @@ private Type GetUniqueConstraintViolationExceptionType()
     {
       var providerName = ProviderInfo.ProviderName;
       switch (providerName) {
-        case WellKnown.Provider.MySql:
         case WellKnown.Provider.Sqlite:
-        case WellKnown.Provider.Firebird:
-          return typeof (StorageException);
+          return typeof(StorageException);
         default:
-        return typeof (UniqueConstraintViolationException);
+          return typeof(UniqueConstraintViolationException);
       }
     }
   }

Orm/Xtensive.Orm.Tests/Storage/QueryBuilderTest.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2012-2020 Xtensive LLC.
+// Copyright (C) 2012-2021 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Denis Krjuchkov
@@ -37,7 +37,7 @@ protected override void PopulateData()
     {
       using (var session = Domain.OpenSession())
       using (var tx = session.OpenTransaction()) {
-        new CheckEntity();
+        _ = new CheckEntity();
         tx.Complete();
       }
     }
@@ -86,7 +86,14 @@ public void ComposeQuery()
         Assert.That(builder, Is.Not.Null);
 
         var binding = builder.CreateParameterBinding(typeof(int), () => 43);
-        var select = SqlDml.Select(binding.ParameterReference);
+        SqlSelect select;
+        if (StorageProviderInfo.Instance.CheckProviderIs(StorageProvider.Firebird)) {
+          //require cast of parameters on sql level
+          select = SqlDml.Select(SqlDml.Cast(binding.ParameterReference, SqlType.Int32));
+        }
+        else {
+          select = SqlDml.Select(binding.ParameterReference);
+        }
 
         var compiled = builder.CompileQuery(select);
         Assert.That(compiled, Is.Not.Null);