Apply Oracle behavior workarounds to some tests

Author: alex-kulakov

Orm/Xtensive.Orm.Tests/Storage/Multinode/QueryCachingTest.cs

@@ -92,9 +92,9 @@ namespace Xtensive.Orm.Tests.Storage.Multinode
 {
   public sealed class QueryCachingTest : MultinodeTest
   {
-    private const string dbo = WellKnownSchemas.SqlServerDefaultSchema;
-    private const string Schema1 = WellKnownSchemas.Schema1;
-    private const string Schema2 = WellKnownSchemas.Schema2;
+    private const string DefaultSchema = WellKnownSchemas.Schema1;
+    private const string Schema1 = WellKnownSchemas.Schema2;
+    private const string Schema2 = WellKnownSchemas.Schema3;
 
     private readonly object SimpleQueryKey = new object();
     private readonly object FilterByIdQueryKey = new object();
@@ -113,21 +113,21 @@ protected override DomainConfiguration BuildConfiguration()
       var configuration = base.BuildConfiguration();
       configuration.Types.Register(typeof(BaseTestEntity).Assembly, typeof(BaseTestEntity).Namespace);
       configuration.UpgradeMode = DomainUpgradeMode.Recreate;
-      configuration.DefaultSchema = dbo;
+      configuration.DefaultSchema = DefaultSchema;
       return configuration;
     }
 
     protected override void PopulateNodes()
     {
       CustomUpgradeHandler.CurrentNodeId = TestNodeId2;
       var nodeConfiguration = new NodeConfiguration(TestNodeId2);
-      nodeConfiguration.SchemaMapping.Add(dbo, Schema1);
+      nodeConfiguration.SchemaMapping.Add(DefaultSchema, Schema1);
       nodeConfiguration.UpgradeMode = DomainUpgradeMode.Recreate;
       _ = Domain.StorageNodeManager.AddNode(nodeConfiguration);
 
       CustomUpgradeHandler.CurrentNodeId = TestNodeId3;
       nodeConfiguration = new NodeConfiguration(TestNodeId3);
-      nodeConfiguration.SchemaMapping.Add(dbo, Schema2);
+      nodeConfiguration.SchemaMapping.Add(DefaultSchema, Schema2);
       nodeConfiguration.UpgradeMode = DomainUpgradeMode.Recreate;
       _ = Domain.StorageNodeManager.AddNode(nodeConfiguration);
     }
@@ -142,68 +142,70 @@ protected override void PopulateData()
         using (var tx = session.OpenTransaction()) {
           #region Entity creation
 
-          _ = new BaseTestEntity(session) { BaseName = "A", BaseOwnerNodeId = nodeId };
+          var nodeIdName = string.IsNullOrEmpty(nodeId) ? "<default>" : nodeId;
+
+          _ = new BaseTestEntity(session) { BaseName = "A", BaseOwnerNodeId = nodeIdName };
           _ = new MiddleTestEntity(session) {
             BaseName = "AA",
             MiddleName = "AAM",
-            BaseOwnerNodeId = nodeId,
-            MiddleOwnerNodeId = nodeId
+            BaseOwnerNodeId = nodeIdName,
+            MiddleOwnerNodeId = nodeIdName
           };
           _ = new LeafTestEntity(session) {
             BaseName = "AAA",
             MiddleName = "AAAM",
             LeafName = "AAAL",
-            BaseOwnerNodeId = nodeId,
-            MiddleOwnerNodeId = nodeId,
-            LeafOwnerNodeId = nodeId
+            BaseOwnerNodeId = nodeIdName,
+            MiddleOwnerNodeId = nodeIdName,
+            LeafOwnerNodeId = nodeIdName
           };
 
-          _ = new BaseTestEntity(session) { BaseName = "B", BaseOwnerNodeId = nodeId };
+          _ = new BaseTestEntity(session) { BaseName = "B", BaseOwnerNodeId = nodeIdName };
           _ = new MiddleTestEntity(session) {
             BaseName = "BB",
             MiddleName = "BBM",
-            BaseOwnerNodeId = nodeId,
-            MiddleOwnerNodeId = nodeId
+            BaseOwnerNodeId = nodeIdName,
+            MiddleOwnerNodeId = nodeIdName
           };
           _ = new LeafTestEntity(session) {
             BaseName = "BBB",
             MiddleName = "BBBM",
             LeafName = "BBBL",
-            BaseOwnerNodeId = nodeId,
-            MiddleOwnerNodeId = nodeId,
-            LeafOwnerNodeId = nodeId
+            BaseOwnerNodeId = nodeIdName,
+            MiddleOwnerNodeId = nodeIdName,
+            LeafOwnerNodeId = nodeIdName
           };
 
-          _ = new BaseTestEntity(session) { BaseName = "C", BaseOwnerNodeId = nodeId };
+          _ = new BaseTestEntity(session) { BaseName = "C", BaseOwnerNodeId = nodeIdName };
           _ = new MiddleTestEntity(session) {
             BaseName = "CC",
             MiddleName = "CCM",
-            BaseOwnerNodeId = nodeId,
-            MiddleOwnerNodeId = nodeId
+            BaseOwnerNodeId = nodeIdName,
+            MiddleOwnerNodeId = nodeIdName
           };
           _ = new LeafTestEntity(session) {
             BaseName = "CCC",
             MiddleName = "CCCM",
             LeafName = "CCCL",
-            BaseOwnerNodeId = nodeId,
-            MiddleOwnerNodeId = nodeId,
-            LeafOwnerNodeId = nodeId
+            BaseOwnerNodeId = nodeIdName,
+            MiddleOwnerNodeId = nodeIdName,
+            LeafOwnerNodeId = nodeIdName
           };
 
-          _ = new BaseTestEntity(session) { BaseName = "D", BaseOwnerNodeId = nodeId };
+          _ = new BaseTestEntity(session) { BaseName = "D", BaseOwnerNodeId = nodeIdName };
           _ = new MiddleTestEntity(session) {
             BaseName = "DD",
             MiddleName = "DDM",
-            BaseOwnerNodeId = nodeId,
-            MiddleOwnerNodeId = nodeId
+            BaseOwnerNodeId = nodeIdName,
+            MiddleOwnerNodeId = nodeIdName
           };
           _ = new LeafTestEntity(session) {
             BaseName = "DDD",
             MiddleName = "DDDM",
             LeafName = "DDDL",
-            BaseOwnerNodeId = nodeId,
-            MiddleOwnerNodeId = nodeId,
-            LeafOwnerNodeId = nodeId
+            BaseOwnerNodeId = nodeIdName,
+            MiddleOwnerNodeId = nodeIdName,
+            LeafOwnerNodeId = nodeIdName
           };
 
           #endregion
@@ -254,10 +256,11 @@ private void RunTestSimpleQueryTest(string nodeId)
       using (var session = selectedNode.OpenSession())
       using (var tx = session.OpenTransaction()) {
         var expectedTypeId = GetExpectedTypeId(nodeId);
+        var nodeIdName = string.IsNullOrEmpty(nodeId) ? "<default>" : nodeId;
 
         var allResults = ExecuteSimpleQueryNoCache(session).OrderBy(e => e.TypeId).ToList();
         Assert.That(allResults.Count, Is.EqualTo(3));
-        Assert.That(allResults.All(e => e.BaseOwnerNodeId == nodeId), Is.True);
+        Assert.That(allResults.All(e => e.BaseOwnerNodeId == nodeIdName), Is.True);
         Assert.That(allResults[0].BaseName, Is.EqualTo("C"));
         Assert.That(allResults[0].TypeId, Is.EqualTo(expectedTypeId));
         Assert.That(allResults[1].BaseName, Is.EqualTo("CC"));
@@ -267,18 +270,18 @@ private void RunTestSimpleQueryTest(string nodeId)
 
         var middles = allResults.OfType<MiddleTestEntity>().ToList();
         Assert.That(middles.Count, Is.EqualTo(2));
-        Assert.That(middles.All(e => e.MiddleOwnerNodeId == nodeId), Is.True);
+        Assert.That(middles.All(e => e.MiddleOwnerNodeId == nodeIdName), Is.True);
         Assert.That(middles[0].MiddleName, Is.EqualTo("CCM"));
         Assert.That(middles[1].MiddleName, Is.EqualTo("CCCM"));
 
         var leafs = middles.OfType<LeafTestEntity>().ToList();
         Assert.That(leafs.Count, Is.EqualTo(1));
-        Assert.That(leafs[0].LeafOwnerNodeId, Is.EqualTo(nodeId));
+        Assert.That(leafs[0].LeafOwnerNodeId, Is.EqualTo(nodeIdName));
         Assert.That(leafs[0].LeafName, Is.EqualTo("CCCL"));
 
         allResults = ExecuteSimpleQueryCaching(session);
         Assert.That(allResults.Count, Is.EqualTo(3));
-        Assert.That(allResults.All(e => e.BaseOwnerNodeId == nodeId), Is.True);
+        Assert.That(allResults.All(e => e.BaseOwnerNodeId == nodeIdName), Is.True);
         Assert.That(allResults[0].BaseName, Is.EqualTo("B"));
         Assert.That(allResults[0].TypeId, Is.EqualTo(expectedTypeId));
         Assert.That(allResults[1].BaseName, Is.EqualTo("BB"));
@@ -288,13 +291,13 @@ private void RunTestSimpleQueryTest(string nodeId)
 
         middles = allResults.OfType<MiddleTestEntity>().ToList();
         Assert.That(middles.Count, Is.EqualTo(2));
-        Assert.That(middles.All(e => e.MiddleOwnerNodeId == nodeId), Is.True);
+        Assert.That(middles.All(e => e.MiddleOwnerNodeId == nodeIdName), Is.True);
         Assert.That(middles[0].MiddleName, Is.EqualTo("BBM"));
         Assert.That(middles[1].MiddleName, Is.EqualTo("BBBM"));
 
         leafs = middles.OfType<LeafTestEntity>().ToList();
         Assert.That(leafs.Count, Is.EqualTo(1));
-        Assert.That(leafs[0].LeafOwnerNodeId, Is.EqualTo(nodeId));
+        Assert.That(leafs[0].LeafOwnerNodeId, Is.EqualTo(nodeIdName));
         Assert.That(leafs[0].LeafName, Is.EqualTo("BBBL"));
       }
     }
@@ -305,50 +308,51 @@ private void RunFilterByTypeIdQueryTest(string nodeId)
       using (var session = selectedNode.OpenSession())
       using (var tx = session.OpenTransaction()) {
         var expectedTypeId = GetExpectedTypeId(nodeId);
+        var nodeIdName = string.IsNullOrEmpty(nodeId) ? "<default>" : nodeId;
 
         var resultWithoutCache = ExecuteFilterByTypeIdNoCache(session, expectedTypeId);
         Assert.That(resultWithoutCache.Count, Is.EqualTo(4));
-        Assert.That(resultWithoutCache.All(e => e.BaseOwnerNodeId == nodeId));
+        Assert.That(resultWithoutCache.All(e => e.BaseOwnerNodeId == nodeIdName));
         Assert.That(resultWithoutCache.All(e => e.TypeId == expectedTypeId), Is.True);
         Assert.That(resultWithoutCache.OfType<BaseTestEntity>().Count(), Is.EqualTo(4));
         Assert.That(resultWithoutCache.OfType<MiddleTestEntity>().Any(), Is.False);
         Assert.That(resultWithoutCache.OfType<LeafTestEntity>().Any(), Is.False);
 
         resultWithoutCache = ExecuteFilterByTypeIdNoCache(session, expectedTypeId + 1);
         Assert.That(resultWithoutCache.Count, Is.EqualTo(4));
-        Assert.That(resultWithoutCache.All(e => e.BaseOwnerNodeId == nodeId));
+        Assert.That(resultWithoutCache.All(e => e.BaseOwnerNodeId == nodeIdName));
         Assert.That(resultWithoutCache.All(e => e.TypeId == expectedTypeId + 1), Is.True);
         Assert.That(resultWithoutCache.OfType<BaseTestEntity>().Count(), Is.EqualTo(4));
         Assert.That(resultWithoutCache.OfType<MiddleTestEntity>().Count(), Is.EqualTo(4));
         Assert.That(resultWithoutCache.OfType<LeafTestEntity>().Any(), Is.False);
 
         resultWithoutCache = ExecuteFilterByTypeIdNoCache(session, expectedTypeId + 2);
         Assert.That(resultWithoutCache.Count, Is.EqualTo(4));
-        Assert.That(resultWithoutCache.All(e => e.BaseOwnerNodeId == nodeId));
+        Assert.That(resultWithoutCache.All(e => e.BaseOwnerNodeId == nodeIdName));
         Assert.That(resultWithoutCache.All(e => e.TypeId == expectedTypeId + 2), Is.True);
         Assert.That(resultWithoutCache.OfType<BaseTestEntity>().Count(), Is.EqualTo(4));
         Assert.That(resultWithoutCache.OfType<MiddleTestEntity>().Count(), Is.EqualTo(4));
         Assert.That(resultWithoutCache.OfType<LeafTestEntity>().Count(), Is.EqualTo(4));
 
         var resultWithCache = ExecuteFilterByTypeIdCaching(session, expectedTypeId);
         Assert.That(resultWithCache.Count, Is.EqualTo(4));
-        Assert.That(resultWithCache.All(e => e.BaseOwnerNodeId == nodeId));
+        Assert.That(resultWithCache.All(e => e.BaseOwnerNodeId == nodeIdName));
         Assert.That(resultWithCache.All(e => e.TypeId == expectedTypeId), Is.True);
         Assert.That(resultWithCache.OfType<BaseTestEntity>().Count(), Is.EqualTo(4));
         Assert.That(resultWithCache.OfType<MiddleTestEntity>().Any(), Is.False);
         Assert.That(resultWithCache.OfType<LeafTestEntity>().Any(), Is.False);
 
         resultWithCache = ExecuteFilterByTypeIdCaching(session, expectedTypeId + 1);
         Assert.That(resultWithCache.Count, Is.EqualTo(4));
-        Assert.That(resultWithCache.All(e => e.BaseOwnerNodeId == nodeId));
+        Assert.That(resultWithCache.All(e => e.BaseOwnerNodeId == nodeIdName));
         Assert.That(resultWithCache.All(e => e.TypeId == expectedTypeId + 1), Is.True);
         Assert.That(resultWithCache.OfType<BaseTestEntity>().Count(), Is.EqualTo(4));
         Assert.That(resultWithCache.OfType<MiddleTestEntity>().Count(), Is.EqualTo(4));
         Assert.That(resultWithCache.OfType<LeafTestEntity>().Any(), Is.False);
 
         resultWithCache = ExecuteFilterByTypeIdCaching(session, expectedTypeId + 2);
         Assert.That(resultWithCache.Count, Is.EqualTo(4));
-        Assert.That(resultWithCache.All(e => e.BaseOwnerNodeId == nodeId));
+        Assert.That(resultWithCache.All(e => e.BaseOwnerNodeId == nodeIdName));
         Assert.That(resultWithCache.All(e => e.TypeId == expectedTypeId + 2), Is.True);
         Assert.That(resultWithCache.OfType<BaseTestEntity>().Count(), Is.EqualTo(4));
         Assert.That(resultWithCache.OfType<MiddleTestEntity>().Count(), Is.EqualTo(4));
@@ -369,28 +373,29 @@ private void RunFilterBySeveralTypeIdsTest(string nodeId)
       using (var session = selectedNode.OpenSession())
       using (var tx = session.OpenTransaction()) {
         var expectedTypeId = GetExpectedTypeId(nodeId);
+        var nodeIdName = string.IsNullOrEmpty(nodeId) ? "<default>" : nodeId;
 
         var allResults = ExecuteFilterBySeveralTypeIdsNoCache(session, new[] { expectedTypeId, expectedTypeId + 1 })
           .OrderBy(e => e.TypeId)
           .ToList();
         Assert.That(allResults.Count, Is.EqualTo(8));
-        Assert.That(allResults.All(e => e.BaseOwnerNodeId == nodeId), Is.True);
+        Assert.That(allResults.All(e => e.BaseOwnerNodeId == nodeIdName), Is.True);
         Assert.That(allResults.Count(e => e.TypeId == expectedTypeId), Is.EqualTo(4));
         Assert.That(allResults.Count(e => e.TypeId == expectedTypeId + 1), Is.EqualTo(4));
 
         var middles = allResults.OfType<MiddleTestEntity>().ToList();
         Assert.That(middles.Count, Is.EqualTo(4));
-        Assert.That(middles.All(e => e.MiddleOwnerNodeId == nodeId), Is.True);
+        Assert.That(middles.All(e => e.MiddleOwnerNodeId == nodeIdName), Is.True);
 
         allResults = ExecuteFilterBySeveralTypeIdsCaching(session, new[] { expectedTypeId, expectedTypeId + 1 });
         Assert.That(allResults.Count, Is.EqualTo(8));
-        Assert.That(allResults.All(e => e.BaseOwnerNodeId == nodeId), Is.True);
+        Assert.That(allResults.All(e => e.BaseOwnerNodeId == nodeIdName), Is.True);
         Assert.That(allResults.Count(e => e.TypeId == expectedTypeId), Is.EqualTo(4));
         Assert.That(allResults.Count(e => e.TypeId == expectedTypeId + 1), Is.EqualTo(4));
 
         middles = allResults.OfType<MiddleTestEntity>().ToList();
         Assert.That(middles.Count, Is.EqualTo(4));
-        Assert.That(middles.All(e => e.MiddleOwnerNodeId == nodeId), Is.True);
+        Assert.That(middles.All(e => e.MiddleOwnerNodeId == nodeIdName), Is.True);
 
         var unexpectedTypeIds = GetUnexpectedTypeIds(nodeId);
         allResults = ExecuteFilterBySeveralTypeIdsNoCache(session, unexpectedTypeIds);

Orm/Xtensive.Orm.Tests/Storage/SchemaSharing/EntityManipulation/Model.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2017 Xtensive LLC.
+// Copyright (C) 2017 Xtensive LLC.
 // All rights reserved.
 // For conditions of distribution and use, see license.
 // Created by: Alexey Kulakov
@@ -22,6 +22,11 @@ public class TestEntity1 : Entity
 
       [Field]
       public string SchemaName { get; set; }
+
+      public TestEntity1(Session session)
+        : base(session)
+      {
+      }
     }
   }
 
@@ -41,6 +46,11 @@ public class TestEntity2 : Entity
 
       [Field]
       public string SchemaName { get; set; }
+
+      public TestEntity2(Session session)
+        : base(session)
+      {
+      }
     }
   }
 
@@ -60,6 +70,11 @@ public class TestEntity3 : Entity
 
       [Field]
       public string SchemaName { get; set; }
+
+      public TestEntity3(Session session)
+        : base(session)
+      {
+      }
     }
   }
 
@@ -79,6 +94,11 @@ public class TestEntity4 : Entity
 
       [Field]
       public string SchemaName { get; set; }
+
+      public TestEntity4(Session session)
+        : base(session)
+      {
+      }
     }
   }