Changes tests to work with new QueryResult's behavior

Author: alex-kulakov

Orm/Xtensive.Orm.Tests/Storage/AsyncQueries/DelayedQueryClientProfileTest.cs

@@ -37,7 +37,7 @@ public async Task EnumerationOutsideTransactionTest()
           result = await session.Query.CreateDelayedQuery(q => q.All<Discepline>())
             .ExecuteAsync();
         }
-        _ = result.ToList();
+        _ = Assert.Throws<InvalidOperationException>(() => result.ToList());
       }
     }
   }

Orm/Xtensive.Orm.Tests/Storage/AsyncQueries/DelayedQueryServerProfileTest.cs

@@ -40,11 +40,10 @@ public async Task EnumerationOutsideTransactionTest()
           result = await session.Query.CreateDelayedQuery(q => q.All<Discepline>())
             .ExecuteAsync();
         }
-        // because of materialization of fetched results not because of check in DelayedQuery.MaterializeAsync()
-        //result.ToList();
+
         var ex = Assert.Throws<InvalidOperationException>(() => result.ToList());
         Assert.That(ex.Message,
-          Is.EqualTo(Strings.ExActiveTransactionIsRequiredForThisOperationUseSessionOpenTransactionToOpenIt));
+          Is.EqualTo(Strings.ExThisInstanceIsExpiredDueToTransactionBoundaries));
       }
     }
   }

Orm/Xtensive.Orm.Tests/Storage/AsyncQueries/DelayedQueryTestBase.cs

@@ -92,15 +92,11 @@ public async Task EnumerationOutsideSessionTest()
       QueryResult<Discepline> result;
       await using (var session = Domain.OpenSession(SessionConfiguration))
       using (var tx = GetTransactionScope(session)) {
-        result =await session.Query.CreateDelayedQuery(q => q.All<Discepline>())
+        result = await session.Query.CreateDelayedQuery(q => q.All<Discepline>())
           .ExecuteAsync();
       }
 
-      // we didn't get StorageException here because we cache results and close db reader so
-      // we materialize cached tuples to entity states which needs a session.
-      // But the session is disposed so we have an exeption
-
-      var ex = Assert.Throws<ObjectDisposedException>(() => result.ToList());
+      var ex = Assert.Throws<InvalidOperationException>(() => result.ToList());
     }
 
     [Test]
@@ -150,14 +146,7 @@ public async Task EnumerationInOuterTransactionAfterInnerRollbackTest()
               .ExecuteAsync();
           }
 
-          // this is tricky. we've read results in one transaction, rollbacked it
-          // and materialize results in another thansaction, which is not cool
-          // because the data which existed in the inner transaction may not exist in the outer
-          // so we can get "ghost" data.
-
-          // some exception has to appear.
-          var ex = Assert.Throws<StorageException>(() => result.ToList());
-          Assert.That(ex.InnerException, Is.TypeOf<InvalidOperationException>());
+          _ = Assert.Throws<InvalidOperationException>(() => result.ToList());
         }
       }
     }

Orm/Xtensive.Orm.Tests/Storage/QueryResultTest.cs

@@ -107,13 +107,8 @@ public void EnumerationOutsideTransactionTest()
         using (var transaction = session.OpenTransaction()) {
           result = session.Query.Execute(q => q.All<Order>());
         }
-        if (SupportsMars()) {
-          var ex = Assert.Throws<StorageException>(() => result.ToList());
-          Assert.That(ex.InnerException, Is.TypeOf<InvalidOperationException>());
-        }
-        else {
-          _ = Assert.Throws<InvalidOperationException>(() => result.ToList());
-        }
+
+        _ = Assert.Throws<InvalidOperationException>(() => result.ToList());
       }
     }
 
@@ -125,13 +120,8 @@ public async Task EnumerationOutsideTransactionAsyncTest()
         using (var transaction = session.OpenTransaction()) {
           result = await session.Query.ExecuteAsync(q => q.All<Order>());
         }
-        if (SupportsMars()) {
-          var ex = Assert.Throws<StorageException>(() => result.ToList());
-          Assert.That(ex.InnerException, Is.TypeOf<InvalidOperationException>());
-        }
-        else {
-          _ = Assert.Throws<InvalidOperationException>(() => result.ToList());
-        }
+
+        _ = Assert.Throws<InvalidOperationException>(() => result.ToList());
       }
     }
 
@@ -165,13 +155,8 @@ public void EnumerationOutsideTransactionClientProfileTest()
         using (var transaction = session.OpenTransaction()) {
           result = session.Query.Execute(q => q.All<Order>());
         }
-        if (SupportsMars()) {
-          var ex = Assert.Throws<StorageException>(() => result.ToList());
-          Assert.That(ex.InnerException, Is.TypeOf<InvalidOperationException>());
-        }
-        else {
-          _ = result.ToList();
-        }
+
+        _ = Assert.Throws<InvalidOperationException>(() => result.ToList());
       }
     }
 
@@ -184,13 +169,8 @@ public async Task EnumerationOutsideTransactionClientProfileAsyncTest()
         using (var transaction = session.OpenTransaction()) {
           result = await session.Query.ExecuteAsync(q => q.All<Order>());
         }
-        if (SupportsMars()) {
-          var ex = Assert.Throws<StorageException>(() => result.ToList());
-          Assert.That(ex.InnerException, Is.TypeOf<InvalidOperationException>());
-        }
-        else {
-          _ = result.ToList();
-        }
+
+        _ = Assert.Throws<InvalidOperationException>(() => result.ToList());
       }
     }
 
@@ -202,13 +182,8 @@ public void EnumerationOutsideSessionTest()
       using (var transaction = session.OpenTransaction()) {
         result = session.Query.Execute(q => q.All<Order>());
       }
-      if (SupportsMars()) {
-        var ex = Assert.Throws<StorageException>(() => result.ToList());
-        Assert.That(ex.InnerException, Is.TypeOf<InvalidOperationException>());
-      }
-      else {
-        var ex = Assert.Throws<ObjectDisposedException>(() => result.ToList());
-      }
+
+      _ = Assert.Throws<InvalidOperationException>(() => result.ToList());
     }
 
     [Test]
@@ -220,13 +195,7 @@ public async Task EnumerationOutsideSessionAsyncTest()
         result = await session.Query.ExecuteAsync(q => q.All<Order>());
       }
 
-      if (SupportsMars()) {
-        var ex = Assert.Throws<StorageException>(() => result.ToList());
-        Assert.That(ex.InnerException, Is.TypeOf<InvalidOperationException>());
-      }
-      else {
-        var ex = Assert.Throws<ObjectDisposedException>(() => result.ToList());
-      }
+      _ = Assert.Throws<InvalidOperationException>(() => result.ToList());
     }
 
     [Test]
@@ -321,29 +290,49 @@ public async Task EnumerationInInnerVoidTransactionAsyncTest()
     [Test]
     public void EnumerationInOuterTransactionAfterInnerRollbackTest()
     {
+      // sql server does not pull results to memory in client library
+      var directReader = StorageProviderInfo.Instance.CheckProviderIs(StorageProvider.SqlServer);
+
       using (var session = Domain.OpenSession()) {
         QueryResult<Order> result;
-        using (var outerTx = session.OpenTransaction()) {
-          using (var innerTx = session.OpenTransaction(TransactionOpenMode.New)) {
-            result = session.Query.Execute(q => q.All<Order>());
-          }
-          var ex = Assert.Throws<StorageException>(() => result.ToList());
-          Assert.That(ex.InnerException, Is.TypeOf<InvalidOperationException>());
+        // no using intentionally
+        var outerTx = session.OpenTransaction();
+        var innerTx = session.OpenTransaction(TransactionOpenMode.New);
+
+        result = session.Query.Execute(q => q.All<Order>());
+
+        if (directReader) {
+          _ = Assert.Throws<StorageException>(() => innerTx.Dispose());
+          _ = Assert.Throws<StorageException>(() => outerTx.Dispose());
+        }
+        else {
+          Assert.DoesNotThrow(() => innerTx.Dispose());
+          Assert.DoesNotThrow(() => outerTx.Dispose());
         }
       }
     }
 
     [Test]
     public async Task EnumerationInOuterTransactionAfterInnerRollbackAsyncTest()
     {
+      // sql server does not pull results to memory in client library
+      var directReader = StorageProviderInfo.Instance.CheckProviderIs(StorageProvider.SqlServer);
+
       using (var session = Domain.OpenSession()) {
         QueryResult<Order> result;
-        using (var outerTx = session.OpenTransaction()) {
-          using (var innerTx = session.OpenTransaction(TransactionOpenMode.New)) {
-            result = await session.Query.ExecuteAsync(q => q.All<Order>());
-          }
-          var ex = Assert.Throws<StorageException>(() => result.ToList());
-          Assert.That(ex.InnerException, Is.TypeOf<InvalidOperationException>());
+        // no using intentionally
+        var outerTx = session.OpenTransaction();
+        var innerTx = session.OpenTransaction(TransactionOpenMode.New);
+
+        result = await session.Query.ExecuteAsync(q => q.All<Order>());
+
+        if (directReader) {
+          _ = Assert.Throws<StorageException>(() => innerTx.Dispose());
+          _ = Assert.Throws<StorageException>(() => outerTx.Dispose());
+        }
+        else {
+          Assert.DoesNotThrow(() => innerTx.Dispose());
+          Assert.DoesNotThrow(() => outerTx.Dispose());
         }
       }
     }