From 73fc3ad498acb5e873717b1dc9911cb5743d52c1 Mon Sep 17 00:00:00 2001 From: gliljas Date: Wed, 26 Aug 2020 18:12:52 +0200 Subject: [PATCH 1/9] Modified Linq Enum unit tests to test alternate mappings --- src/NHibernate.Test/Linq/EnumTests.cs | 224 +++++++++++++++++++------- 1 file changed, 168 insertions(+), 56 deletions(-) diff --git a/src/NHibernate.Test/Linq/EnumTests.cs b/src/NHibernate.Test/Linq/EnumTests.cs index 7f312de7e42..a8ff118174e 100644 --- a/src/NHibernate.Test/Linq/EnumTests.cs +++ b/src/NHibernate.Test/Linq/EnumTests.cs @@ -1,97 +1,209 @@ -using System.Linq; -using NHibernate.DomainModel.Northwind.Entities; +using System; +using System.Linq; +using NHibernate.Cfg.MappingSchema; +using NHibernate.Mapping.ByCode; +using NHibernate.SqlTypes; +using NHibernate.Type; using NUnit.Framework; namespace NHibernate.Test.Linq { - [TestFixture] - public class EnumTests : LinqTestCase + [TestFixture(typeof(EnumType))] + [TestFixture(typeof(EnumStringType))] + [TestFixture(typeof(EnumAnsiStringType))] + public class EnumTests : TestCaseMappingByCode { - [Test] - public void CanQueryOnEnumStoredAsInt32_High_1() + private IType _enumType; + + + public EnumTests(System.Type enumType) { - CanQueryOnEnumStoredAsInt32(EnumStoredAsInt32.High, 1); + _enumType = (IType) Activator.CreateInstance(enumType); } - [Test] - public void CanQueryOnEnumStoredAsInt32_Unspecified_2() + protected override HbmMapping GetMappings() + { + var mapper = new ModelMapper(); + mapper.Class( + rc => + { + rc.Table("EnumEntity"); + rc.Id(x => x.Id, m => m.Generator(Generators.Identity)); + rc.Property(x => x.Name); + rc.Property(x => x.Enum, m => m.Type(_enumType)); + rc.Property(x => x.NullableEnum, m => m.Type(_enumType)); + rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All)); + }); + + + return mapper.CompileMappingForAllExplicitlyAddedEntities(); + } + + protected override void OnSetUp() { - CanQueryOnEnumStoredAsInt32(EnumStoredAsInt32.Unspecified, 2); + base.OnSetUp(); + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + session.Save(new EnumEntity { Enum = TestEnum.Unspecified }); + session.Save(new EnumEntity { Enum = TestEnum.Small }); + session.Save(new EnumEntity { Enum = TestEnum.Small }); + session.Save(new EnumEntity { Enum = TestEnum.Medium }); + session.Save(new EnumEntity { Enum = TestEnum.Medium }); + session.Save(new EnumEntity { Enum = TestEnum.Medium }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + trans.Commit(); + } } - public void CanQueryOnEnumStoredAsInt32(EnumStoredAsInt32 type, int expectedCount) + protected override void OnTearDown() { - var query = (from user in db.Users - where user.Enum2 == type - select user).ToList(); + using (var session = OpenSession()) + using (var transaction = session.BeginTransaction()) + { + session.Delete("from System.Object"); - Assert.AreEqual(expectedCount, query.Count); + session.Flush(); + transaction.Commit(); + } } [Test] - public void CanQueryOnEnumStoredAsString_Meduim_2() + public void CanQueryOnEnum_Large_4() { - CanQueryOnEnumStoredAsString(EnumStoredAsString.Medium, 2); + CanQueryOnEnum(TestEnum.Large, 4); } [Test] - public void CanQueryOnEnumStoredAsString_Small_1() + public void CanQueryOnEnum_Medium_3() { - CanQueryOnEnumStoredAsString(EnumStoredAsString.Small, 1); + CanQueryOnEnum(TestEnum.Medium, 3); } - public void CanQueryOnEnumStoredAsString(EnumStoredAsString type, int expectedCount) + [Test] + public void CanQueryOnEnum_Small_2() { - var query = (from user in db.Users - where user.Enum1 == type - select user).ToList(); + CanQueryOnEnum(TestEnum.Small, 2); + } - Assert.AreEqual(expectedCount, query.Count); + [Test] + public void CanQueryOnEnum_Unspecified_1() + { + CanQueryOnEnum(TestEnum.Unspecified, 1); + } + + private void CanQueryOnEnum(TestEnum type, int expectedCount) + { + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var query = session.Query().Where(x => x.Enum == type).ToList(); + + Assert.AreEqual(expectedCount, query.Count); + } } [Test] - public void CanQueryWithContainsOnEnumStoredAsString_Small_1() + public void CanQueryWithContainsOnTestEnum_Small_1() { - var values = new[] { EnumStoredAsString.Small, EnumStoredAsString.Medium }; - var query = db.Users.Where(x => values.Contains(x.Enum1)).ToList(); - Assert.AreEqual(3, query.Count); + var values = new[] { TestEnum.Small, TestEnum.Medium }; + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var query = session.Query().Where(x => values.Contains(x.Enum)).ToList(); + + Assert.AreEqual(5, query.Count); + } } [Test] public void ConditionalNavigationProperty() { - EnumStoredAsString? type = null; - db.Users.Where(o => o.Enum1 == EnumStoredAsString.Large).ToList(); - db.Users.Where(o => EnumStoredAsString.Large != o.Enum1).ToList(); - db.Users.Where(o => (o.NullableEnum1 ?? EnumStoredAsString.Large) == EnumStoredAsString.Medium).ToList(); - db.Users.Where(o => ((o.NullableEnum1 ?? type) ?? o.Enum1) == EnumStoredAsString.Medium).ToList(); - - db.Users.Where(o => (o.NullableEnum1.HasValue ? o.Enum1 : EnumStoredAsString.Unspecified) == EnumStoredAsString.Medium).ToList(); - db.Users.Where(o => (o.Enum1 != EnumStoredAsString.Large - ? (o.NullableEnum1.HasValue ? o.Enum1 : EnumStoredAsString.Unspecified) - : EnumStoredAsString.Small) == EnumStoredAsString.Medium).ToList(); - - db.Users.Where(o => (o.Enum1 == EnumStoredAsString.Large ? o.Role : o.Role).Name == "test").ToList(); + TestEnum? type = null; + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var entities = session.Query(); + entities.Where(o => o.Enum == TestEnum.Large).ToList(); + entities.Where(o => TestEnum.Large != o.Enum).ToList(); + entities.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToList(); + entities.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToList(); + + entities.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToList(); + entities.Where(o => (o.Enum != TestEnum.Large + ? (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) + : TestEnum.Small) == TestEnum.Medium).ToList(); + + entities.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToList(); + } } [Test] - public void CanQueryComplexExpressionOnEnumStoredAsString() + public void CanQueryComplexExpressionOnTestEnum() + { + var type = TestEnum.Unspecified; + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var entities = session.Query(); + + var query = (from user in entities + where (user.NullableEnum == TestEnum.Large + ? TestEnum.Medium + : user.NullableEnum ?? user.Enum + ) == type + select new + { + user, + simple = user.Enum, + condition = user.Enum == TestEnum.Large ? TestEnum.Medium : user.Enum, + coalesce = user.NullableEnum ?? TestEnum.Medium + }).ToList(); + + Assert.That(query.Count, Is.EqualTo(1)); + } + } + + public class EnumEntity + { + public virtual int Id { get; set; } + public virtual string Name { get; set; } + + public virtual TestEnum Enum { get; set; } + public virtual TestEnum? NullableEnum { get; set; } + + public virtual EnumEntity Other { get; set; } + } + + public enum TestEnum { - var type = EnumStoredAsString.Unspecified; - var query = (from user in db.Users - where (user.NullableEnum1 == EnumStoredAsString.Large - ? EnumStoredAsString.Medium - : user.NullableEnum1 ?? user.Enum1 - ) == type - select new - { - user, - simple = user.Enum1, - condition = user.Enum1 == EnumStoredAsString.Large ? EnumStoredAsString.Medium : user.Enum1, - coalesce = user.NullableEnum1 ?? EnumStoredAsString.Medium - }).ToList(); - - Assert.That(query.Count, Is.EqualTo(0)); + Unspecified, + Small, + Medium, + Large + } + + [Serializable] + public class EnumAnsiStringType : EnumStringType + { + private readonly string typeName; + + public EnumAnsiStringType() + : base(typeof(T)) + { + System.Type type = GetType(); + typeName = type.FullName + ", " + type.Assembly.GetName().Name; + } + + public override string Name + { + get { return typeName; } + } + + public override SqlType SqlType => SqlTypeFactory.GetAnsiString(255); } } } From c0bf3c60b8893592ffacea597c710121a2bbda72 Mon Sep 17 00:00:00 2001 From: gliljas Date: Wed, 26 Aug 2020 18:13:17 +0200 Subject: [PATCH 2/9] Check if enum is mapped as any kind of string --- .../Linq/Visitors/HqlGeneratorExpressionVisitor.cs | 2 +- src/NHibernate/Util/DbTypeExtensions.cs | 14 ++++++++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) create mode 100644 src/NHibernate/Util/DbTypeExtensions.cs diff --git a/src/NHibernate/Linq/Visitors/HqlGeneratorExpressionVisitor.cs b/src/NHibernate/Linq/Visitors/HqlGeneratorExpressionVisitor.cs index 34315c240d2..35df768b2a0 100644 --- a/src/NHibernate/Linq/Visitors/HqlGeneratorExpressionVisitor.cs +++ b/src/NHibernate/Linq/Visitors/HqlGeneratorExpressionVisitor.cs @@ -634,7 +634,7 @@ private bool IsCastRequired(IType type, IType toType, out bool existType) return false; } - if (type.ReturnedClass.IsEnum && sqlTypes[0].DbType == DbType.String) + if (type.ReturnedClass.IsEnum && sqlTypes[0].DbType.IsStringType()) { existType = false; return false; // Never cast an enum that is mapped as string, the type will provide a string for the parameter value diff --git a/src/NHibernate/Util/DbTypeExtensions.cs b/src/NHibernate/Util/DbTypeExtensions.cs new file mode 100644 index 00000000000..1ba7acb2af1 --- /dev/null +++ b/src/NHibernate/Util/DbTypeExtensions.cs @@ -0,0 +1,14 @@ +using System.Data; + +namespace NHibernate.Util +{ + public static class DbTypeExtensions + { + /// + /// Checks whether the type is a , , or + /// + /// + /// + public static bool IsStringType(this DbType dbType) => dbType == DbType.String || dbType == DbType.AnsiString || dbType == DbType.StringFixedLength || dbType == DbType.AnsiStringFixedLength; + } +} From 56427431bf5d26fb9d79693a398f8694bf736d9f Mon Sep 17 00:00:00 2001 From: Alex Zaytsev Date: Thu, 27 Aug 2020 09:49:26 +1200 Subject: [PATCH 3/9] Make DbTypeExtensions internal --- src/NHibernate/Util/DbTypeExtensions.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/NHibernate/Util/DbTypeExtensions.cs b/src/NHibernate/Util/DbTypeExtensions.cs index 1ba7acb2af1..5f56a0d56c8 100644 --- a/src/NHibernate/Util/DbTypeExtensions.cs +++ b/src/NHibernate/Util/DbTypeExtensions.cs @@ -2,7 +2,7 @@ namespace NHibernate.Util { - public static class DbTypeExtensions + internal static class DbTypeExtensions { /// /// Checks whether the type is a , , or From 5a90a745d4eecce951eac5acc05d257270e15c10 Mon Sep 17 00:00:00 2001 From: Alex Zaytsev Date: Thu, 27 Aug 2020 09:54:21 +1200 Subject: [PATCH 4/9] Async regen --- src/NHibernate.Test/Async/Linq/EnumTests.cs | 222 +++++++++++++++----- 1 file changed, 167 insertions(+), 55 deletions(-) diff --git a/src/NHibernate.Test/Async/Linq/EnumTests.cs b/src/NHibernate.Test/Async/Linq/EnumTests.cs index e08a2c90829..d083e8f9bbf 100644 --- a/src/NHibernate.Test/Async/Linq/EnumTests.cs +++ b/src/NHibernate.Test/Async/Linq/EnumTests.cs @@ -8,8 +8,12 @@ //------------------------------------------------------------------------------ +using System; using System.Linq; -using NHibernate.DomainModel.Northwind.Entities; +using NHibernate.Cfg.MappingSchema; +using NHibernate.Mapping.ByCode; +using NHibernate.SqlTypes; +using NHibernate.Type; using NUnit.Framework; using NHibernate.Linq; @@ -17,94 +21,202 @@ namespace NHibernate.Test.Linq { using System.Threading.Tasks; using System.Threading; - [TestFixture] - public class EnumTestsAsync : LinqTestCase + [TestFixture(typeof(EnumType))] + [TestFixture(typeof(EnumStringType))] + [TestFixture(typeof(EnumAnsiStringType))] + public class EnumTestsAsync : TestCaseMappingByCode { - [Test] - public async Task CanQueryOnEnumStoredAsInt32_High_1Async() + private IType _enumType; + + + public EnumTestsAsync(System.Type enumType) { - await (CanQueryOnEnumStoredAsInt32Async(EnumStoredAsInt32.High, 1)); + _enumType = (IType) Activator.CreateInstance(enumType); } - [Test] - public async Task CanQueryOnEnumStoredAsInt32_Unspecified_2Async() + protected override HbmMapping GetMappings() + { + var mapper = new ModelMapper(); + mapper.Class( + rc => + { + rc.Table("EnumEntity"); + rc.Id(x => x.Id, m => m.Generator(Generators.Identity)); + rc.Property(x => x.Name); + rc.Property(x => x.Enum, m => m.Type(_enumType)); + rc.Property(x => x.NullableEnum, m => m.Type(_enumType)); + rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All)); + }); + + + return mapper.CompileMappingForAllExplicitlyAddedEntities(); + } + + protected override void OnSetUp() { - await (CanQueryOnEnumStoredAsInt32Async(EnumStoredAsInt32.Unspecified, 2)); + base.OnSetUp(); + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + session.Save(new EnumEntity { Enum = TestEnum.Unspecified }); + session.Save(new EnumEntity { Enum = TestEnum.Small }); + session.Save(new EnumEntity { Enum = TestEnum.Small }); + session.Save(new EnumEntity { Enum = TestEnum.Medium }); + session.Save(new EnumEntity { Enum = TestEnum.Medium }); + session.Save(new EnumEntity { Enum = TestEnum.Medium }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + trans.Commit(); + } } - public async Task CanQueryOnEnumStoredAsInt32Async(EnumStoredAsInt32 type, int expectedCount, CancellationToken cancellationToken = default(CancellationToken)) + protected override void OnTearDown() { - var query = await ((from user in db.Users - where user.Enum2 == type - select user).ToListAsync(cancellationToken)); + using (var session = OpenSession()) + using (var transaction = session.BeginTransaction()) + { + session.Delete("from System.Object"); + + session.Flush(); + transaction.Commit(); + } + } - Assert.AreEqual(expectedCount, query.Count); + [Test] + public async Task CanQueryOnEnum_Large_4Async() + { + await (CanQueryOnEnumAsync(TestEnum.Large, 4)); + } + + [Test] + public async Task CanQueryOnEnum_Medium_3Async() + { + await (CanQueryOnEnumAsync(TestEnum.Medium, 3)); } [Test] - public async Task CanQueryOnEnumStoredAsString_Meduim_2Async() + public async Task CanQueryOnEnum_Small_2Async() { - await (CanQueryOnEnumStoredAsStringAsync(EnumStoredAsString.Medium, 2)); + await (CanQueryOnEnumAsync(TestEnum.Small, 2)); } [Test] - public async Task CanQueryOnEnumStoredAsString_Small_1Async() + public async Task CanQueryOnEnum_Unspecified_1Async() { - await (CanQueryOnEnumStoredAsStringAsync(EnumStoredAsString.Small, 1)); + await (CanQueryOnEnumAsync(TestEnum.Unspecified, 1)); } - public async Task CanQueryOnEnumStoredAsStringAsync(EnumStoredAsString type, int expectedCount, CancellationToken cancellationToken = default(CancellationToken)) + private async Task CanQueryOnEnumAsync(TestEnum type, int expectedCount, CancellationToken cancellationToken = default(CancellationToken)) { - var query = await ((from user in db.Users - where user.Enum1 == type - select user).ToListAsync(cancellationToken)); + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var query = await (session.Query().Where(x => x.Enum == type).ToListAsync(cancellationToken)); - Assert.AreEqual(expectedCount, query.Count); + Assert.AreEqual(expectedCount, query.Count); + } } [Test] - public async Task CanQueryWithContainsOnEnumStoredAsString_Small_1Async() + public async Task CanQueryWithContainsOnTestEnum_Small_1Async() { - var values = new[] { EnumStoredAsString.Small, EnumStoredAsString.Medium }; - var query = await (db.Users.Where(x => values.Contains(x.Enum1)).ToListAsync()); - Assert.AreEqual(3, query.Count); + var values = new[] { TestEnum.Small, TestEnum.Medium }; + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var query = await (session.Query().Where(x => values.Contains(x.Enum)).ToListAsync()); + + Assert.AreEqual(5, query.Count); + } } [Test] public async Task ConditionalNavigationPropertyAsync() { - EnumStoredAsString? type = null; - await (db.Users.Where(o => o.Enum1 == EnumStoredAsString.Large).ToListAsync()); - await (db.Users.Where(o => EnumStoredAsString.Large != o.Enum1).ToListAsync()); - await (db.Users.Where(o => (o.NullableEnum1 ?? EnumStoredAsString.Large) == EnumStoredAsString.Medium).ToListAsync()); - await (db.Users.Where(o => ((o.NullableEnum1 ?? type) ?? o.Enum1) == EnumStoredAsString.Medium).ToListAsync()); - - await (db.Users.Where(o => (o.NullableEnum1.HasValue ? o.Enum1 : EnumStoredAsString.Unspecified) == EnumStoredAsString.Medium).ToListAsync()); - await (db.Users.Where(o => (o.Enum1 != EnumStoredAsString.Large - ? (o.NullableEnum1.HasValue ? o.Enum1 : EnumStoredAsString.Unspecified) - : EnumStoredAsString.Small) == EnumStoredAsString.Medium).ToListAsync()); - - await (db.Users.Where(o => (o.Enum1 == EnumStoredAsString.Large ? o.Role : o.Role).Name == "test").ToListAsync()); + TestEnum? type = null; + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var entities = session.Query(); + await (entities.Where(o => o.Enum == TestEnum.Large).ToListAsync()); + await (entities.Where(o => TestEnum.Large != o.Enum).ToListAsync()); + await (entities.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToListAsync()); + await (entities.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToListAsync()); + + await (entities.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToListAsync()); + await (entities.Where(o => (o.Enum != TestEnum.Large + ? (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) + : TestEnum.Small) == TestEnum.Medium).ToListAsync()); + + await (entities.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToListAsync()); + } } [Test] - public async Task CanQueryComplexExpressionOnEnumStoredAsStringAsync() + public async Task CanQueryComplexExpressionOnTestEnumAsync() { - var type = EnumStoredAsString.Unspecified; - var query = await ((from user in db.Users - where (user.NullableEnum1 == EnumStoredAsString.Large - ? EnumStoredAsString.Medium - : user.NullableEnum1 ?? user.Enum1 - ) == type - select new - { - user, - simple = user.Enum1, - condition = user.Enum1 == EnumStoredAsString.Large ? EnumStoredAsString.Medium : user.Enum1, - coalesce = user.NullableEnum1 ?? EnumStoredAsString.Medium - }).ToListAsync()); - - Assert.That(query.Count, Is.EqualTo(0)); + var type = TestEnum.Unspecified; + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var entities = session.Query(); + + var query = await ((from user in entities + where (user.NullableEnum == TestEnum.Large + ? TestEnum.Medium + : user.NullableEnum ?? user.Enum + ) == type + select new + { + user, + simple = user.Enum, + condition = user.Enum == TestEnum.Large ? TestEnum.Medium : user.Enum, + coalesce = user.NullableEnum ?? TestEnum.Medium + }).ToListAsync()); + + Assert.That(query.Count, Is.EqualTo(1)); + } + } + + public class EnumEntity + { + public virtual int Id { get; set; } + public virtual string Name { get; set; } + + public virtual TestEnum Enum { get; set; } + public virtual TestEnum? NullableEnum { get; set; } + + public virtual EnumEntity Other { get; set; } + } + + public enum TestEnum + { + Unspecified, + Small, + Medium, + Large + } + + [Serializable] + public class EnumAnsiStringType : EnumStringType + { + private readonly string typeName; + + public EnumAnsiStringType() + : base(typeof(T)) + { + System.Type type = GetType(); + typeName = type.FullName + ", " + type.Assembly.GetName().Name; + } + + public override string Name + { + get { return typeName; } + } + + public override SqlType SqlType => SqlTypeFactory.GetAnsiString(255); } } } From b82d1e149ef47f98e043ec64075b8850577ed21d Mon Sep 17 00:00:00 2001 From: gliljas Date: Thu, 27 Aug 2020 16:54:52 +0200 Subject: [PATCH 5/9] Modified tests --- src/NHibernate.Test/Async/Linq/EnumTests.cs | 139 ++++++++++++-------- src/NHibernate.Test/Linq/EnumTests.cs | 137 +++++++++++-------- 2 files changed, 163 insertions(+), 113 deletions(-) diff --git a/src/NHibernate.Test/Async/Linq/EnumTests.cs b/src/NHibernate.Test/Async/Linq/EnumTests.cs index d083e8f9bbf..08cb051de6d 100644 --- a/src/NHibernate.Test/Async/Linq/EnumTests.cs +++ b/src/NHibernate.Test/Async/Linq/EnumTests.cs @@ -21,13 +21,18 @@ namespace NHibernate.Test.Linq { using System.Threading.Tasks; using System.Threading; + using System.Linq.Expressions; + [TestFixture(typeof(EnumType))] [TestFixture(typeof(EnumStringType))] [TestFixture(typeof(EnumAnsiStringType))] public class EnumTestsAsync : TestCaseMappingByCode { private IType _enumType; + private ISession _session; + private IQueryable TestEntities { get; set; } + private IQueryable TestEntitiesInDb { get; set; } public EnumTestsAsync(System.Type enumType) { @@ -43,6 +48,7 @@ protected override HbmMapping GetMappings() rc.Table("EnumEntity"); rc.Id(x => x.Id, m => m.Generator(Generators.Identity)); rc.Property(x => x.Name); + rc.Property(x => x.BatchId); rc.Property(x => x.Enum, m => m.Type(_enumType)); rc.Property(x => x.NullableEnum, m => m.Type(_enumType)); rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All)); @@ -55,25 +61,43 @@ protected override HbmMapping GetMappings() protected override void OnSetUp() { base.OnSetUp(); - using (var session = OpenSession()) - using (var trans = session.BeginTransaction()) + _session = OpenSession(); + + var entities = new[] { + new EnumEntity { Enum = TestEnum.Unspecified }, + new EnumEntity { Enum = TestEnum.Small, NullableEnum = TestEnum.Large }, + new EnumEntity { Enum = TestEnum.Small, NullableEnum = TestEnum.Medium }, + new EnumEntity { Enum = TestEnum.Medium, NullableEnum = TestEnum.Medium }, + new EnumEntity { Enum = TestEnum.Medium, NullableEnum = TestEnum.Small }, + new EnumEntity { Enum = TestEnum.Medium }, + new EnumEntity { Enum = TestEnum.Large, NullableEnum = TestEnum.Medium }, + new EnumEntity { Enum = TestEnum.Large, NullableEnum = TestEnum.Unspecified }, + new EnumEntity { Enum = TestEnum.Large }, + new EnumEntity { Enum = TestEnum.Large } + }; + + var batchId = Guid.NewGuid(); + + using (var trans = _session.BeginTransaction()) { - session.Save(new EnumEntity { Enum = TestEnum.Unspecified }); - session.Save(new EnumEntity { Enum = TestEnum.Small }); - session.Save(new EnumEntity { Enum = TestEnum.Small }); - session.Save(new EnumEntity { Enum = TestEnum.Medium }); - session.Save(new EnumEntity { Enum = TestEnum.Medium }); - session.Save(new EnumEntity { Enum = TestEnum.Medium }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); + foreach (var item in entities) + { + item.BatchId = batchId; + _session.Save(item); + } trans.Commit(); } + + TestEntitiesInDb = _session.Query().Where(x => x.BatchId == batchId); + TestEntities = entities.AsQueryable(); } protected override void OnTearDown() { + if (_session.IsOpen) + { + _session.Close(); + } using (var session = OpenSession()) using (var transaction = session.BeginTransaction()) { @@ -108,76 +132,68 @@ public async Task CanQueryOnEnum_Unspecified_1Async() await (CanQueryOnEnumAsync(TestEnum.Unspecified, 1)); } - private async Task CanQueryOnEnumAsync(TestEnum type, int expectedCount, CancellationToken cancellationToken = default(CancellationToken)) + private async Task CanQueryOnEnumAsync(TestEnum type, int expectedCount) { - using (var session = OpenSession()) - using (var trans = session.BeginTransaction()) - { - var query = await (session.Query().Where(x => x.Enum == type).ToListAsync(cancellationToken)); + var query = await (TestEntitiesInDb.Where(x => x.Enum == type).ToListAsync()); - Assert.AreEqual(expectedCount, query.Count); - } + Assert.AreEqual(expectedCount, query.Count); } [Test] public async Task CanQueryWithContainsOnTestEnum_Small_1Async() { var values = new[] { TestEnum.Small, TestEnum.Medium }; - using (var session = OpenSession()) - using (var trans = session.BeginTransaction()) - { - var query = await (session.Query().Where(x => values.Contains(x.Enum)).ToListAsync()); - Assert.AreEqual(5, query.Count); - } + var query = await (TestEntitiesInDb.Where(x => values.Contains(x.Enum)).ToListAsync()); + + Assert.AreEqual(5, query.Count); } [Test] public async Task ConditionalNavigationPropertyAsync() { TestEnum? type = null; - using (var session = OpenSession()) - using (var trans = session.BeginTransaction()) - { - var entities = session.Query(); - await (entities.Where(o => o.Enum == TestEnum.Large).ToListAsync()); - await (entities.Where(o => TestEnum.Large != o.Enum).ToListAsync()); - await (entities.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToListAsync()); - await (entities.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToListAsync()); - - await (entities.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToListAsync()); - await (entities.Where(o => (o.Enum != TestEnum.Large + + + await (TestEntitiesInDb.Where(o => o.Enum == TestEnum.Large).ToListAsync()); + await (TestEntitiesInDb.Where(o => TestEnum.Large != o.Enum).ToListAsync()); + await (TestEntitiesInDb.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToListAsync()); + await (TestEntitiesInDb.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToListAsync()); + + await (TestEntitiesInDb.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToListAsync()); + await (TestEntitiesInDb.Where(o => (o.Enum != TestEnum.Large ? (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) : TestEnum.Small) == TestEnum.Medium).ToListAsync()); - await (entities.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToListAsync()); - } + await (TestEntitiesInDb.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToListAsync()); } [Test] public async Task CanQueryComplexExpressionOnTestEnumAsync() { var type = TestEnum.Unspecified; - using (var session = OpenSession()) - using (var trans = session.BeginTransaction()) + + Expression> predicate = user => (user.NullableEnum == TestEnum.Large + ? TestEnum.Medium + : user.NullableEnum ?? user.Enum + ) == type; + + var query = await (TestEntitiesInDb.Where(predicate).Select(entity => new ProjectedEnum { - var entities = session.Query(); - - var query = await ((from user in entities - where (user.NullableEnum == TestEnum.Large - ? TestEnum.Medium - : user.NullableEnum ?? user.Enum - ) == type - select new - { - user, - simple = user.Enum, - condition = user.Enum == TestEnum.Large ? TestEnum.Medium : user.Enum, - coalesce = user.NullableEnum ?? TestEnum.Medium - }).ToListAsync()); - - Assert.That(query.Count, Is.EqualTo(1)); - } + Entity = entity, + Simple = entity.Enum, + Condition = entity.Enum == TestEnum.Large ? TestEnum.Medium : entity.Enum, + Coalesce = entity.NullableEnum ?? TestEnum.Medium + }).ToListAsync()); + + var targetCount = TestEntities.Count(predicate); //the truth + Assert.That(targetCount, Is.GreaterThan(0)); //test sanity check + Assert.That(query.Count, Is.EqualTo(targetCount)); + + Assert.That(query, Is.All.Matches(x => x.Simple == x.Entity.Enum)); + Assert.That(query, Is.All.Matches(x => x.Condition == (x.Entity.Enum == TestEnum.Large ? TestEnum.Medium : x.Entity.Enum))); + Assert.That(query, Is.All.Matches(x => x.Coalesce == (x.Entity.NullableEnum ?? TestEnum.Medium))); + } public class EnumEntity @@ -189,6 +205,7 @@ public class EnumEntity public virtual TestEnum? NullableEnum { get; set; } public virtual EnumEntity Other { get; set; } + public virtual Guid BatchId { get; set; } } public enum TestEnum @@ -218,5 +235,13 @@ public override string Name public override SqlType SqlType => SqlTypeFactory.GetAnsiString(255); } + + private class ProjectedEnum + { + public TestEnum Simple { get; internal set; } + public TestEnum Condition { get; internal set; } + public TestEnum Coalesce { get; internal set; } + public EnumEntity Entity { get; internal set; } + } } } diff --git a/src/NHibernate.Test/Linq/EnumTests.cs b/src/NHibernate.Test/Linq/EnumTests.cs index a8ff118174e..6e14a6f3a48 100644 --- a/src/NHibernate.Test/Linq/EnumTests.cs +++ b/src/NHibernate.Test/Linq/EnumTests.cs @@ -1,9 +1,11 @@ using System; using System.Linq; +using System.Linq.Expressions; using NHibernate.Cfg.MappingSchema; using NHibernate.Mapping.ByCode; using NHibernate.SqlTypes; using NHibernate.Type; +using NHibernate.Util; using NUnit.Framework; namespace NHibernate.Test.Linq @@ -14,7 +16,10 @@ namespace NHibernate.Test.Linq public class EnumTests : TestCaseMappingByCode { private IType _enumType; + private ISession _session; + private IQueryable TestEntities { get; set; } + private IQueryable TestEntitiesInDb { get; set; } public EnumTests(System.Type enumType) { @@ -30,6 +35,7 @@ protected override HbmMapping GetMappings() rc.Table("EnumEntity"); rc.Id(x => x.Id, m => m.Generator(Generators.Identity)); rc.Property(x => x.Name); + rc.Property(x => x.BatchId); rc.Property(x => x.Enum, m => m.Type(_enumType)); rc.Property(x => x.NullableEnum, m => m.Type(_enumType)); rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All)); @@ -42,25 +48,43 @@ protected override HbmMapping GetMappings() protected override void OnSetUp() { base.OnSetUp(); - using (var session = OpenSession()) - using (var trans = session.BeginTransaction()) + _session = OpenSession(); + + var entities = new[] { + new EnumEntity { Enum = TestEnum.Unspecified }, + new EnumEntity { Enum = TestEnum.Small, NullableEnum = TestEnum.Large }, + new EnumEntity { Enum = TestEnum.Small, NullableEnum = TestEnum.Medium }, + new EnumEntity { Enum = TestEnum.Medium, NullableEnum = TestEnum.Medium }, + new EnumEntity { Enum = TestEnum.Medium, NullableEnum = TestEnum.Small }, + new EnumEntity { Enum = TestEnum.Medium }, + new EnumEntity { Enum = TestEnum.Large, NullableEnum = TestEnum.Medium }, + new EnumEntity { Enum = TestEnum.Large, NullableEnum = TestEnum.Unspecified }, + new EnumEntity { Enum = TestEnum.Large }, + new EnumEntity { Enum = TestEnum.Large } + }; + + var batchId = Guid.NewGuid(); + + using (var trans = _session.BeginTransaction()) { - session.Save(new EnumEntity { Enum = TestEnum.Unspecified }); - session.Save(new EnumEntity { Enum = TestEnum.Small }); - session.Save(new EnumEntity { Enum = TestEnum.Small }); - session.Save(new EnumEntity { Enum = TestEnum.Medium }); - session.Save(new EnumEntity { Enum = TestEnum.Medium }); - session.Save(new EnumEntity { Enum = TestEnum.Medium }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); + foreach (var item in entities) + { + item.BatchId = batchId; + _session.Save(item); + } trans.Commit(); } + + TestEntitiesInDb = _session.Query().Where(x=>x.BatchId == batchId); + TestEntities = entities.AsQueryable(); } protected override void OnTearDown() { + if (_session.IsOpen) + { + _session.Close(); + } using (var session = OpenSession()) using (var transaction = session.BeginTransaction()) { @@ -97,74 +121,66 @@ public void CanQueryOnEnum_Unspecified_1() private void CanQueryOnEnum(TestEnum type, int expectedCount) { - using (var session = OpenSession()) - using (var trans = session.BeginTransaction()) - { - var query = session.Query().Where(x => x.Enum == type).ToList(); + var query = TestEntitiesInDb.Where(x => x.Enum == type).ToList(); - Assert.AreEqual(expectedCount, query.Count); - } + Assert.AreEqual(expectedCount, query.Count); } [Test] public void CanQueryWithContainsOnTestEnum_Small_1() { var values = new[] { TestEnum.Small, TestEnum.Medium }; - using (var session = OpenSession()) - using (var trans = session.BeginTransaction()) - { - var query = session.Query().Where(x => values.Contains(x.Enum)).ToList(); - Assert.AreEqual(5, query.Count); - } + var query = TestEntitiesInDb.Where(x => values.Contains(x.Enum)).ToList(); + + Assert.AreEqual(5, query.Count); } [Test] public void ConditionalNavigationProperty() { TestEnum? type = null; - using (var session = OpenSession()) - using (var trans = session.BeginTransaction()) - { - var entities = session.Query(); - entities.Where(o => o.Enum == TestEnum.Large).ToList(); - entities.Where(o => TestEnum.Large != o.Enum).ToList(); - entities.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToList(); - entities.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToList(); - - entities.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToList(); - entities.Where(o => (o.Enum != TestEnum.Large + + + TestEntitiesInDb.Where(o => o.Enum == TestEnum.Large).ToList(); + TestEntitiesInDb.Where(o => TestEnum.Large != o.Enum).ToList(); + TestEntitiesInDb.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToList(); + TestEntitiesInDb.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToList(); + + TestEntitiesInDb.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToList(); + TestEntitiesInDb.Where(o => (o.Enum != TestEnum.Large ? (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) : TestEnum.Small) == TestEnum.Medium).ToList(); - entities.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToList(); - } + TestEntitiesInDb.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToList(); } [Test] public void CanQueryComplexExpressionOnTestEnum() { var type = TestEnum.Unspecified; - using (var session = OpenSession()) - using (var trans = session.BeginTransaction()) + + Expression> predicate = user => (user.NullableEnum == TestEnum.Large + ? TestEnum.Medium + : user.NullableEnum ?? user.Enum + ) == type; + + var query = TestEntitiesInDb.Where(predicate).Select(entity => new ProjectedEnum { - var entities = session.Query(); - - var query = (from user in entities - where (user.NullableEnum == TestEnum.Large - ? TestEnum.Medium - : user.NullableEnum ?? user.Enum - ) == type - select new - { - user, - simple = user.Enum, - condition = user.Enum == TestEnum.Large ? TestEnum.Medium : user.Enum, - coalesce = user.NullableEnum ?? TestEnum.Medium - }).ToList(); - - Assert.That(query.Count, Is.EqualTo(1)); - } + Entity = entity, + Simple = entity.Enum, + Condition = entity.Enum == TestEnum.Large ? TestEnum.Medium : entity.Enum, + Coalesce = entity.NullableEnum ?? TestEnum.Medium + }).ToList(); + + var targetCount = TestEntities.Count(predicate); //the truth + Assert.That(targetCount, Is.GreaterThan(0)); //test sanity check + Assert.That(query.Count, Is.EqualTo(targetCount)); + + Assert.That(query, Is.All.Matches(x => x.Simple == x.Entity.Enum)); + Assert.That(query, Is.All.Matches(x => x.Condition == (x.Entity.Enum == TestEnum.Large ? TestEnum.Medium : x.Entity.Enum))); + Assert.That(query, Is.All.Matches(x => x.Coalesce == (x.Entity.NullableEnum ?? TestEnum.Medium))); + } public class EnumEntity @@ -176,6 +192,7 @@ public class EnumEntity public virtual TestEnum? NullableEnum { get; set; } public virtual EnumEntity Other { get; set; } + public virtual Guid BatchId { get; set; } } public enum TestEnum @@ -205,5 +222,13 @@ public override string Name public override SqlType SqlType => SqlTypeFactory.GetAnsiString(255); } + + private class ProjectedEnum + { + public TestEnum Simple { get; internal set; } + public TestEnum Condition { get; internal set; } + public TestEnum Coalesce { get; internal set; } + public EnumEntity Entity { get; internal set; } + } } } From 20d453af4359d12201fe58589acf820c13ff0c9d Mon Sep 17 00:00:00 2001 From: gliljas Date: Fri, 28 Aug 2020 11:06:05 +0200 Subject: [PATCH 6/9] Revert "Modified tests" This reverts commit b82d1e149ef47f98e043ec64075b8850577ed21d. --- src/NHibernate.Test/Async/Linq/EnumTests.cs | 139 ++++++++------------ src/NHibernate.Test/Linq/EnumTests.cs | 137 ++++++++----------- 2 files changed, 113 insertions(+), 163 deletions(-) diff --git a/src/NHibernate.Test/Async/Linq/EnumTests.cs b/src/NHibernate.Test/Async/Linq/EnumTests.cs index 08cb051de6d..d083e8f9bbf 100644 --- a/src/NHibernate.Test/Async/Linq/EnumTests.cs +++ b/src/NHibernate.Test/Async/Linq/EnumTests.cs @@ -21,18 +21,13 @@ namespace NHibernate.Test.Linq { using System.Threading.Tasks; using System.Threading; - using System.Linq.Expressions; - [TestFixture(typeof(EnumType))] [TestFixture(typeof(EnumStringType))] [TestFixture(typeof(EnumAnsiStringType))] public class EnumTestsAsync : TestCaseMappingByCode { private IType _enumType; - private ISession _session; - private IQueryable TestEntities { get; set; } - private IQueryable TestEntitiesInDb { get; set; } public EnumTestsAsync(System.Type enumType) { @@ -48,7 +43,6 @@ protected override HbmMapping GetMappings() rc.Table("EnumEntity"); rc.Id(x => x.Id, m => m.Generator(Generators.Identity)); rc.Property(x => x.Name); - rc.Property(x => x.BatchId); rc.Property(x => x.Enum, m => m.Type(_enumType)); rc.Property(x => x.NullableEnum, m => m.Type(_enumType)); rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All)); @@ -61,43 +55,25 @@ protected override HbmMapping GetMappings() protected override void OnSetUp() { base.OnSetUp(); - _session = OpenSession(); - - var entities = new[] { - new EnumEntity { Enum = TestEnum.Unspecified }, - new EnumEntity { Enum = TestEnum.Small, NullableEnum = TestEnum.Large }, - new EnumEntity { Enum = TestEnum.Small, NullableEnum = TestEnum.Medium }, - new EnumEntity { Enum = TestEnum.Medium, NullableEnum = TestEnum.Medium }, - new EnumEntity { Enum = TestEnum.Medium, NullableEnum = TestEnum.Small }, - new EnumEntity { Enum = TestEnum.Medium }, - new EnumEntity { Enum = TestEnum.Large, NullableEnum = TestEnum.Medium }, - new EnumEntity { Enum = TestEnum.Large, NullableEnum = TestEnum.Unspecified }, - new EnumEntity { Enum = TestEnum.Large }, - new EnumEntity { Enum = TestEnum.Large } - }; - - var batchId = Guid.NewGuid(); - - using (var trans = _session.BeginTransaction()) + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) { - foreach (var item in entities) - { - item.BatchId = batchId; - _session.Save(item); - } + session.Save(new EnumEntity { Enum = TestEnum.Unspecified }); + session.Save(new EnumEntity { Enum = TestEnum.Small }); + session.Save(new EnumEntity { Enum = TestEnum.Small }); + session.Save(new EnumEntity { Enum = TestEnum.Medium }); + session.Save(new EnumEntity { Enum = TestEnum.Medium }); + session.Save(new EnumEntity { Enum = TestEnum.Medium }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); trans.Commit(); } - - TestEntitiesInDb = _session.Query().Where(x => x.BatchId == batchId); - TestEntities = entities.AsQueryable(); } protected override void OnTearDown() { - if (_session.IsOpen) - { - _session.Close(); - } using (var session = OpenSession()) using (var transaction = session.BeginTransaction()) { @@ -132,68 +108,76 @@ public async Task CanQueryOnEnum_Unspecified_1Async() await (CanQueryOnEnumAsync(TestEnum.Unspecified, 1)); } - private async Task CanQueryOnEnumAsync(TestEnum type, int expectedCount) + private async Task CanQueryOnEnumAsync(TestEnum type, int expectedCount, CancellationToken cancellationToken = default(CancellationToken)) { - var query = await (TestEntitiesInDb.Where(x => x.Enum == type).ToListAsync()); + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var query = await (session.Query().Where(x => x.Enum == type).ToListAsync(cancellationToken)); - Assert.AreEqual(expectedCount, query.Count); + Assert.AreEqual(expectedCount, query.Count); + } } [Test] public async Task CanQueryWithContainsOnTestEnum_Small_1Async() { var values = new[] { TestEnum.Small, TestEnum.Medium }; + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var query = await (session.Query().Where(x => values.Contains(x.Enum)).ToListAsync()); - var query = await (TestEntitiesInDb.Where(x => values.Contains(x.Enum)).ToListAsync()); - - Assert.AreEqual(5, query.Count); + Assert.AreEqual(5, query.Count); + } } [Test] public async Task ConditionalNavigationPropertyAsync() { TestEnum? type = null; - - - await (TestEntitiesInDb.Where(o => o.Enum == TestEnum.Large).ToListAsync()); - await (TestEntitiesInDb.Where(o => TestEnum.Large != o.Enum).ToListAsync()); - await (TestEntitiesInDb.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToListAsync()); - await (TestEntitiesInDb.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToListAsync()); - - await (TestEntitiesInDb.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToListAsync()); - await (TestEntitiesInDb.Where(o => (o.Enum != TestEnum.Large + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var entities = session.Query(); + await (entities.Where(o => o.Enum == TestEnum.Large).ToListAsync()); + await (entities.Where(o => TestEnum.Large != o.Enum).ToListAsync()); + await (entities.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToListAsync()); + await (entities.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToListAsync()); + + await (entities.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToListAsync()); + await (entities.Where(o => (o.Enum != TestEnum.Large ? (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) : TestEnum.Small) == TestEnum.Medium).ToListAsync()); - await (TestEntitiesInDb.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToListAsync()); + await (entities.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToListAsync()); + } } [Test] public async Task CanQueryComplexExpressionOnTestEnumAsync() { var type = TestEnum.Unspecified; - - Expression> predicate = user => (user.NullableEnum == TestEnum.Large - ? TestEnum.Medium - : user.NullableEnum ?? user.Enum - ) == type; - - var query = await (TestEntitiesInDb.Where(predicate).Select(entity => new ProjectedEnum + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) { - Entity = entity, - Simple = entity.Enum, - Condition = entity.Enum == TestEnum.Large ? TestEnum.Medium : entity.Enum, - Coalesce = entity.NullableEnum ?? TestEnum.Medium - }).ToListAsync()); - - var targetCount = TestEntities.Count(predicate); //the truth - Assert.That(targetCount, Is.GreaterThan(0)); //test sanity check - Assert.That(query.Count, Is.EqualTo(targetCount)); - - Assert.That(query, Is.All.Matches(x => x.Simple == x.Entity.Enum)); - Assert.That(query, Is.All.Matches(x => x.Condition == (x.Entity.Enum == TestEnum.Large ? TestEnum.Medium : x.Entity.Enum))); - Assert.That(query, Is.All.Matches(x => x.Coalesce == (x.Entity.NullableEnum ?? TestEnum.Medium))); - + var entities = session.Query(); + + var query = await ((from user in entities + where (user.NullableEnum == TestEnum.Large + ? TestEnum.Medium + : user.NullableEnum ?? user.Enum + ) == type + select new + { + user, + simple = user.Enum, + condition = user.Enum == TestEnum.Large ? TestEnum.Medium : user.Enum, + coalesce = user.NullableEnum ?? TestEnum.Medium + }).ToListAsync()); + + Assert.That(query.Count, Is.EqualTo(1)); + } } public class EnumEntity @@ -205,7 +189,6 @@ public class EnumEntity public virtual TestEnum? NullableEnum { get; set; } public virtual EnumEntity Other { get; set; } - public virtual Guid BatchId { get; set; } } public enum TestEnum @@ -235,13 +218,5 @@ public override string Name public override SqlType SqlType => SqlTypeFactory.GetAnsiString(255); } - - private class ProjectedEnum - { - public TestEnum Simple { get; internal set; } - public TestEnum Condition { get; internal set; } - public TestEnum Coalesce { get; internal set; } - public EnumEntity Entity { get; internal set; } - } } } diff --git a/src/NHibernate.Test/Linq/EnumTests.cs b/src/NHibernate.Test/Linq/EnumTests.cs index 6e14a6f3a48..a8ff118174e 100644 --- a/src/NHibernate.Test/Linq/EnumTests.cs +++ b/src/NHibernate.Test/Linq/EnumTests.cs @@ -1,11 +1,9 @@ using System; using System.Linq; -using System.Linq.Expressions; using NHibernate.Cfg.MappingSchema; using NHibernate.Mapping.ByCode; using NHibernate.SqlTypes; using NHibernate.Type; -using NHibernate.Util; using NUnit.Framework; namespace NHibernate.Test.Linq @@ -16,10 +14,7 @@ namespace NHibernate.Test.Linq public class EnumTests : TestCaseMappingByCode { private IType _enumType; - private ISession _session; - private IQueryable TestEntities { get; set; } - private IQueryable TestEntitiesInDb { get; set; } public EnumTests(System.Type enumType) { @@ -35,7 +30,6 @@ protected override HbmMapping GetMappings() rc.Table("EnumEntity"); rc.Id(x => x.Id, m => m.Generator(Generators.Identity)); rc.Property(x => x.Name); - rc.Property(x => x.BatchId); rc.Property(x => x.Enum, m => m.Type(_enumType)); rc.Property(x => x.NullableEnum, m => m.Type(_enumType)); rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All)); @@ -48,43 +42,25 @@ protected override HbmMapping GetMappings() protected override void OnSetUp() { base.OnSetUp(); - _session = OpenSession(); - - var entities = new[] { - new EnumEntity { Enum = TestEnum.Unspecified }, - new EnumEntity { Enum = TestEnum.Small, NullableEnum = TestEnum.Large }, - new EnumEntity { Enum = TestEnum.Small, NullableEnum = TestEnum.Medium }, - new EnumEntity { Enum = TestEnum.Medium, NullableEnum = TestEnum.Medium }, - new EnumEntity { Enum = TestEnum.Medium, NullableEnum = TestEnum.Small }, - new EnumEntity { Enum = TestEnum.Medium }, - new EnumEntity { Enum = TestEnum.Large, NullableEnum = TestEnum.Medium }, - new EnumEntity { Enum = TestEnum.Large, NullableEnum = TestEnum.Unspecified }, - new EnumEntity { Enum = TestEnum.Large }, - new EnumEntity { Enum = TestEnum.Large } - }; - - var batchId = Guid.NewGuid(); - - using (var trans = _session.BeginTransaction()) + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) { - foreach (var item in entities) - { - item.BatchId = batchId; - _session.Save(item); - } + session.Save(new EnumEntity { Enum = TestEnum.Unspecified }); + session.Save(new EnumEntity { Enum = TestEnum.Small }); + session.Save(new EnumEntity { Enum = TestEnum.Small }); + session.Save(new EnumEntity { Enum = TestEnum.Medium }); + session.Save(new EnumEntity { Enum = TestEnum.Medium }); + session.Save(new EnumEntity { Enum = TestEnum.Medium }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum = TestEnum.Large }); trans.Commit(); } - - TestEntitiesInDb = _session.Query().Where(x=>x.BatchId == batchId); - TestEntities = entities.AsQueryable(); } protected override void OnTearDown() { - if (_session.IsOpen) - { - _session.Close(); - } using (var session = OpenSession()) using (var transaction = session.BeginTransaction()) { @@ -121,66 +97,74 @@ public void CanQueryOnEnum_Unspecified_1() private void CanQueryOnEnum(TestEnum type, int expectedCount) { - var query = TestEntitiesInDb.Where(x => x.Enum == type).ToList(); + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var query = session.Query().Where(x => x.Enum == type).ToList(); - Assert.AreEqual(expectedCount, query.Count); + Assert.AreEqual(expectedCount, query.Count); + } } [Test] public void CanQueryWithContainsOnTestEnum_Small_1() { var values = new[] { TestEnum.Small, TestEnum.Medium }; + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var query = session.Query().Where(x => values.Contains(x.Enum)).ToList(); - var query = TestEntitiesInDb.Where(x => values.Contains(x.Enum)).ToList(); - - Assert.AreEqual(5, query.Count); + Assert.AreEqual(5, query.Count); + } } [Test] public void ConditionalNavigationProperty() { TestEnum? type = null; - - - TestEntitiesInDb.Where(o => o.Enum == TestEnum.Large).ToList(); - TestEntitiesInDb.Where(o => TestEnum.Large != o.Enum).ToList(); - TestEntitiesInDb.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToList(); - TestEntitiesInDb.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToList(); - - TestEntitiesInDb.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToList(); - TestEntitiesInDb.Where(o => (o.Enum != TestEnum.Large + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) + { + var entities = session.Query(); + entities.Where(o => o.Enum == TestEnum.Large).ToList(); + entities.Where(o => TestEnum.Large != o.Enum).ToList(); + entities.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToList(); + entities.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToList(); + + entities.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToList(); + entities.Where(o => (o.Enum != TestEnum.Large ? (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) : TestEnum.Small) == TestEnum.Medium).ToList(); - TestEntitiesInDb.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToList(); + entities.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToList(); + } } [Test] public void CanQueryComplexExpressionOnTestEnum() { var type = TestEnum.Unspecified; - - Expression> predicate = user => (user.NullableEnum == TestEnum.Large - ? TestEnum.Medium - : user.NullableEnum ?? user.Enum - ) == type; - - var query = TestEntitiesInDb.Where(predicate).Select(entity => new ProjectedEnum + using (var session = OpenSession()) + using (var trans = session.BeginTransaction()) { - Entity = entity, - Simple = entity.Enum, - Condition = entity.Enum == TestEnum.Large ? TestEnum.Medium : entity.Enum, - Coalesce = entity.NullableEnum ?? TestEnum.Medium - }).ToList(); - - var targetCount = TestEntities.Count(predicate); //the truth - Assert.That(targetCount, Is.GreaterThan(0)); //test sanity check - Assert.That(query.Count, Is.EqualTo(targetCount)); - - Assert.That(query, Is.All.Matches(x => x.Simple == x.Entity.Enum)); - Assert.That(query, Is.All.Matches(x => x.Condition == (x.Entity.Enum == TestEnum.Large ? TestEnum.Medium : x.Entity.Enum))); - Assert.That(query, Is.All.Matches(x => x.Coalesce == (x.Entity.NullableEnum ?? TestEnum.Medium))); - + var entities = session.Query(); + + var query = (from user in entities + where (user.NullableEnum == TestEnum.Large + ? TestEnum.Medium + : user.NullableEnum ?? user.Enum + ) == type + select new + { + user, + simple = user.Enum, + condition = user.Enum == TestEnum.Large ? TestEnum.Medium : user.Enum, + coalesce = user.NullableEnum ?? TestEnum.Medium + }).ToList(); + + Assert.That(query.Count, Is.EqualTo(1)); + } } public class EnumEntity @@ -192,7 +176,6 @@ public class EnumEntity public virtual TestEnum? NullableEnum { get; set; } public virtual EnumEntity Other { get; set; } - public virtual Guid BatchId { get; set; } } public enum TestEnum @@ -222,13 +205,5 @@ public override string Name public override SqlType SqlType => SqlTypeFactory.GetAnsiString(255); } - - private class ProjectedEnum - { - public TestEnum Simple { get; internal set; } - public TestEnum Condition { get; internal set; } - public TestEnum Coalesce { get; internal set; } - public EnumEntity Entity { get; internal set; } - } } } From bf5bb34489ee04b69ec29926b1ecbc61ad73908e Mon Sep 17 00:00:00 2001 From: gliljas Date: Fri, 28 Aug 2020 12:24:42 +0200 Subject: [PATCH 7/9] Revert test changes. Added formula. --- src/NHibernate.Test/Async/Linq/EnumTests.cs | 17 +++++++++++------ src/NHibernate.Test/Linq/EnumTests.cs | 17 +++++++++++------ 2 files changed, 22 insertions(+), 12 deletions(-) diff --git a/src/NHibernate.Test/Async/Linq/EnumTests.cs b/src/NHibernate.Test/Async/Linq/EnumTests.cs index d083e8f9bbf..f781641d201 100644 --- a/src/NHibernate.Test/Async/Linq/EnumTests.cs +++ b/src/NHibernate.Test/Async/Linq/EnumTests.cs @@ -21,17 +21,18 @@ namespace NHibernate.Test.Linq { using System.Threading.Tasks; using System.Threading; - [TestFixture(typeof(EnumType))] - [TestFixture(typeof(EnumStringType))] - [TestFixture(typeof(EnumAnsiStringType))] + [TestFixture(typeof(EnumType),"0")] + [TestFixture(typeof(EnumStringType), "'Unspecified'")] + [TestFixture(typeof(EnumAnsiStringType), "'Unspecified'")] public class EnumTestsAsync : TestCaseMappingByCode { private IType _enumType; + private string _unspecifiedValue; - - public EnumTestsAsync(System.Type enumType) + public EnumTestsAsync(System.Type enumType, string unspecifiedValue) { _enumType = (IType) Activator.CreateInstance(enumType); + _unspecifiedValue = unspecifiedValue; } protected override HbmMapping GetMappings() @@ -44,7 +45,11 @@ protected override HbmMapping GetMappings() rc.Id(x => x.Id, m => m.Generator(Generators.Identity)); rc.Property(x => x.Name); rc.Property(x => x.Enum, m => m.Type(_enumType)); - rc.Property(x => x.NullableEnum, m => m.Type(_enumType)); + rc.Property(x => x.NullableEnum, m => + { + m.Type(_enumType); + m.Formula($"(case when Enum = {_unspecifiedValue} then null else Enum end)"); + }); rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All)); }); diff --git a/src/NHibernate.Test/Linq/EnumTests.cs b/src/NHibernate.Test/Linq/EnumTests.cs index a8ff118174e..3d0a1f970d7 100644 --- a/src/NHibernate.Test/Linq/EnumTests.cs +++ b/src/NHibernate.Test/Linq/EnumTests.cs @@ -8,17 +8,18 @@ namespace NHibernate.Test.Linq { - [TestFixture(typeof(EnumType))] - [TestFixture(typeof(EnumStringType))] - [TestFixture(typeof(EnumAnsiStringType))] + [TestFixture(typeof(EnumType),"0")] + [TestFixture(typeof(EnumStringType), "'Unspecified'")] + [TestFixture(typeof(EnumAnsiStringType), "'Unspecified'")] public class EnumTests : TestCaseMappingByCode { private IType _enumType; + private string _unspecifiedValue; - - public EnumTests(System.Type enumType) + public EnumTests(System.Type enumType, string unspecifiedValue) { _enumType = (IType) Activator.CreateInstance(enumType); + _unspecifiedValue = unspecifiedValue; } protected override HbmMapping GetMappings() @@ -31,7 +32,11 @@ protected override HbmMapping GetMappings() rc.Id(x => x.Id, m => m.Generator(Generators.Identity)); rc.Property(x => x.Name); rc.Property(x => x.Enum, m => m.Type(_enumType)); - rc.Property(x => x.NullableEnum, m => m.Type(_enumType)); + rc.Property(x => x.NullableEnum, m => + { + m.Type(_enumType); + m.Formula($"(case when Enum = {_unspecifiedValue} then null else Enum end)"); + }); rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All)); }); From 1764a68c03a63458e3851a1572cf7c9fd34375b4 Mon Sep 17 00:00:00 2001 From: Roman Artiukhin Date: Sat, 29 Aug 2020 13:59:23 +0300 Subject: [PATCH 8/9] Adjust test to make it green --- src/NHibernate.Test/Async/Linq/EnumTests.cs | 5 +++-- src/NHibernate.Test/Linq/EnumTests.cs | 5 +++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/NHibernate.Test/Async/Linq/EnumTests.cs b/src/NHibernate.Test/Async/Linq/EnumTests.cs index f781641d201..92344f363a4 100644 --- a/src/NHibernate.Test/Async/Linq/EnumTests.cs +++ b/src/NHibernate.Test/Async/Linq/EnumTests.cs @@ -162,7 +162,8 @@ public async Task ConditionalNavigationPropertyAsync() [Test] public async Task CanQueryComplexExpressionOnTestEnumAsync() { - var type = TestEnum.Unspecified; + //TODO: Fix issue on SQLite with type set to TestEnum.Unspecified + TestEnum? type = null; using (var session = OpenSession()) using (var trans = session.BeginTransaction()) { @@ -181,7 +182,7 @@ public async Task CanQueryComplexExpressionOnTestEnumAsync() coalesce = user.NullableEnum ?? TestEnum.Medium }).ToListAsync()); - Assert.That(query.Count, Is.EqualTo(1)); + Assert.That(query.Count, Is.EqualTo(0)); } } diff --git a/src/NHibernate.Test/Linq/EnumTests.cs b/src/NHibernate.Test/Linq/EnumTests.cs index 3d0a1f970d7..e0c15acaf2b 100644 --- a/src/NHibernate.Test/Linq/EnumTests.cs +++ b/src/NHibernate.Test/Linq/EnumTests.cs @@ -149,7 +149,8 @@ public void ConditionalNavigationProperty() [Test] public void CanQueryComplexExpressionOnTestEnum() { - var type = TestEnum.Unspecified; + //TODO: Fix issue on SQLite with type set to TestEnum.Unspecified + TestEnum? type = null; using (var session = OpenSession()) using (var trans = session.BeginTransaction()) { @@ -168,7 +169,7 @@ public void CanQueryComplexExpressionOnTestEnum() coalesce = user.NullableEnum ?? TestEnum.Medium }).ToList(); - Assert.That(query.Count, Is.EqualTo(1)); + Assert.That(query.Count, Is.EqualTo(0)); } } From 7062def179960760f642c6fc484ad911d1d5cf84 Mon Sep 17 00:00:00 2001 From: Roman Artiukhin Date: Sat, 29 Aug 2020 15:01:23 +0300 Subject: [PATCH 9/9] Fix tests for Firebird and MySql --- src/NHibernate.Test/Async/Linq/EnumTests.cs | 102 +++++----------- src/NHibernate.Test/Linq/EnumTests.cs | 123 ++++++++++---------- 2 files changed, 92 insertions(+), 133 deletions(-) diff --git a/src/NHibernate.Test/Async/Linq/EnumTests.cs b/src/NHibernate.Test/Async/Linq/EnumTests.cs index 92344f363a4..21f23a84c8b 100644 --- a/src/NHibernate.Test/Async/Linq/EnumTests.cs +++ b/src/NHibernate.Test/Async/Linq/EnumTests.cs @@ -21,7 +21,7 @@ namespace NHibernate.Test.Linq { using System.Threading.Tasks; using System.Threading; - [TestFixture(typeof(EnumType),"0")] + [TestFixture(typeof(EnumType), "0")] [TestFixture(typeof(EnumStringType), "'Unspecified'")] [TestFixture(typeof(EnumAnsiStringType), "'Unspecified'")] public class EnumTestsAsync : TestCaseMappingByCode @@ -42,18 +42,17 @@ protected override HbmMapping GetMappings() rc => { rc.Table("EnumEntity"); - rc.Id(x => x.Id, m => m.Generator(Generators.Identity)); + rc.Id(x => x.Id, m => m.Generator(Generators.Guid)); rc.Property(x => x.Name); - rc.Property(x => x.Enum, m => m.Type(_enumType)); - rc.Property(x => x.NullableEnum, m => + rc.Property(x => x.Enum1, m => m.Type(_enumType)); + rc.Property(x => x.NullableEnum1, m => { m.Type(_enumType); - m.Formula($"(case when Enum = {_unspecifiedValue} then null else Enum end)"); + m.Formula($"(case when Enum1 = {_unspecifiedValue} then null else Enum1 end)"); }); rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All)); }); - return mapper.CompileMappingForAllExplicitlyAddedEntities(); } @@ -63,16 +62,16 @@ protected override void OnSetUp() using (var session = OpenSession()) using (var trans = session.BeginTransaction()) { - session.Save(new EnumEntity { Enum = TestEnum.Unspecified }); - session.Save(new EnumEntity { Enum = TestEnum.Small }); - session.Save(new EnumEntity { Enum = TestEnum.Small }); - session.Save(new EnumEntity { Enum = TestEnum.Medium }); - session.Save(new EnumEntity { Enum = TestEnum.Medium }); - session.Save(new EnumEntity { Enum = TestEnum.Medium }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum1 = TestEnum.Unspecified }); + session.Save(new EnumEntity { Enum1 = TestEnum.Small }); + session.Save(new EnumEntity { Enum1 = TestEnum.Small }); + session.Save(new EnumEntity { Enum1 = TestEnum.Medium }); + session.Save(new EnumEntity { Enum1 = TestEnum.Medium }); + session.Save(new EnumEntity { Enum1 = TestEnum.Medium }); + session.Save(new EnumEntity { Enum1 = TestEnum.Large }); + session.Save(new EnumEntity { Enum1 = TestEnum.Large }); + session.Save(new EnumEntity { Enum1 = TestEnum.Large }); + session.Save(new EnumEntity { Enum1 = TestEnum.Large }); trans.Commit(); } } @@ -118,7 +117,7 @@ public async Task CanQueryOnEnum_Unspecified_1Async() using (var session = OpenSession()) using (var trans = session.BeginTransaction()) { - var query = await (session.Query().Where(x => x.Enum == type).ToListAsync(cancellationToken)); + var query = await (session.Query().Where(x => x.Enum1 == type).ToListAsync(cancellationToken)); Assert.AreEqual(expectedCount, query.Count); } @@ -131,7 +130,7 @@ public async Task CanQueryWithContainsOnTestEnum_Small_1Async() using (var session = OpenSession()) using (var trans = session.BeginTransaction()) { - var query = await (session.Query().Where(x => values.Contains(x.Enum)).ToListAsync()); + var query = await (session.Query().Where(x => values.Contains(x.Enum1)).ToListAsync()); Assert.AreEqual(5, query.Count); } @@ -145,17 +144,17 @@ public async Task ConditionalNavigationPropertyAsync() using (var trans = session.BeginTransaction()) { var entities = session.Query(); - await (entities.Where(o => o.Enum == TestEnum.Large).ToListAsync()); - await (entities.Where(o => TestEnum.Large != o.Enum).ToListAsync()); - await (entities.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToListAsync()); - await (entities.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToListAsync()); - - await (entities.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToListAsync()); - await (entities.Where(o => (o.Enum != TestEnum.Large - ? (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) + await (entities.Where(o => o.Enum1 == TestEnum.Large).ToListAsync()); + await (entities.Where(o => TestEnum.Large != o.Enum1).ToListAsync()); + await (entities.Where(o => (o.NullableEnum1 ?? TestEnum.Large) == TestEnum.Medium).ToListAsync()); + await (entities.Where(o => ((o.NullableEnum1 ?? type) ?? o.Enum1) == TestEnum.Medium).ToListAsync()); + + await (entities.Where(o => (o.NullableEnum1.HasValue ? o.Enum1 : TestEnum.Unspecified) == TestEnum.Medium).ToListAsync()); + await (entities.Where(o => (o.Enum1 != TestEnum.Large + ? (o.NullableEnum1.HasValue ? o.Enum1 : TestEnum.Unspecified) : TestEnum.Small) == TestEnum.Medium).ToListAsync()); - await (entities.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToListAsync()); + await (entities.Where(o => (o.Enum1 == TestEnum.Large ? o.Other : o.Other).Name == "test").ToListAsync()); } } @@ -170,59 +169,20 @@ public async Task CanQueryComplexExpressionOnTestEnumAsync() var entities = session.Query(); var query = await ((from user in entities - where (user.NullableEnum == TestEnum.Large + where (user.NullableEnum1 == TestEnum.Large ? TestEnum.Medium - : user.NullableEnum ?? user.Enum + : user.NullableEnum1 ?? user.Enum1 ) == type select new { user, - simple = user.Enum, - condition = user.Enum == TestEnum.Large ? TestEnum.Medium : user.Enum, - coalesce = user.NullableEnum ?? TestEnum.Medium + simple = user.Enum1, + condition = user.Enum1 == TestEnum.Large ? TestEnum.Medium : user.Enum1, + coalesce = user.NullableEnum1 ?? TestEnum.Medium }).ToListAsync()); Assert.That(query.Count, Is.EqualTo(0)); } } - - public class EnumEntity - { - public virtual int Id { get; set; } - public virtual string Name { get; set; } - - public virtual TestEnum Enum { get; set; } - public virtual TestEnum? NullableEnum { get; set; } - - public virtual EnumEntity Other { get; set; } - } - - public enum TestEnum - { - Unspecified, - Small, - Medium, - Large - } - - [Serializable] - public class EnumAnsiStringType : EnumStringType - { - private readonly string typeName; - - public EnumAnsiStringType() - : base(typeof(T)) - { - System.Type type = GetType(); - typeName = type.FullName + ", " + type.Assembly.GetName().Name; - } - - public override string Name - { - get { return typeName; } - } - - public override SqlType SqlType => SqlTypeFactory.GetAnsiString(255); - } } } diff --git a/src/NHibernate.Test/Linq/EnumTests.cs b/src/NHibernate.Test/Linq/EnumTests.cs index e0c15acaf2b..1b01c1706d7 100644 --- a/src/NHibernate.Test/Linq/EnumTests.cs +++ b/src/NHibernate.Test/Linq/EnumTests.cs @@ -8,7 +8,7 @@ namespace NHibernate.Test.Linq { - [TestFixture(typeof(EnumType),"0")] + [TestFixture(typeof(EnumType), "0")] [TestFixture(typeof(EnumStringType), "'Unspecified'")] [TestFixture(typeof(EnumAnsiStringType), "'Unspecified'")] public class EnumTests : TestCaseMappingByCode @@ -29,18 +29,17 @@ protected override HbmMapping GetMappings() rc => { rc.Table("EnumEntity"); - rc.Id(x => x.Id, m => m.Generator(Generators.Identity)); + rc.Id(x => x.Id, m => m.Generator(Generators.Guid)); rc.Property(x => x.Name); - rc.Property(x => x.Enum, m => m.Type(_enumType)); - rc.Property(x => x.NullableEnum, m => + rc.Property(x => x.Enum1, m => m.Type(_enumType)); + rc.Property(x => x.NullableEnum1, m => { m.Type(_enumType); - m.Formula($"(case when Enum = {_unspecifiedValue} then null else Enum end)"); + m.Formula($"(case when Enum1 = {_unspecifiedValue} then null else Enum1 end)"); }); rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All)); }); - return mapper.CompileMappingForAllExplicitlyAddedEntities(); } @@ -50,16 +49,16 @@ protected override void OnSetUp() using (var session = OpenSession()) using (var trans = session.BeginTransaction()) { - session.Save(new EnumEntity { Enum = TestEnum.Unspecified }); - session.Save(new EnumEntity { Enum = TestEnum.Small }); - session.Save(new EnumEntity { Enum = TestEnum.Small }); - session.Save(new EnumEntity { Enum = TestEnum.Medium }); - session.Save(new EnumEntity { Enum = TestEnum.Medium }); - session.Save(new EnumEntity { Enum = TestEnum.Medium }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); - session.Save(new EnumEntity { Enum = TestEnum.Large }); + session.Save(new EnumEntity { Enum1 = TestEnum.Unspecified }); + session.Save(new EnumEntity { Enum1 = TestEnum.Small }); + session.Save(new EnumEntity { Enum1 = TestEnum.Small }); + session.Save(new EnumEntity { Enum1 = TestEnum.Medium }); + session.Save(new EnumEntity { Enum1 = TestEnum.Medium }); + session.Save(new EnumEntity { Enum1 = TestEnum.Medium }); + session.Save(new EnumEntity { Enum1 = TestEnum.Large }); + session.Save(new EnumEntity { Enum1 = TestEnum.Large }); + session.Save(new EnumEntity { Enum1 = TestEnum.Large }); + session.Save(new EnumEntity { Enum1 = TestEnum.Large }); trans.Commit(); } } @@ -105,7 +104,7 @@ private void CanQueryOnEnum(TestEnum type, int expectedCount) using (var session = OpenSession()) using (var trans = session.BeginTransaction()) { - var query = session.Query().Where(x => x.Enum == type).ToList(); + var query = session.Query().Where(x => x.Enum1 == type).ToList(); Assert.AreEqual(expectedCount, query.Count); } @@ -118,7 +117,7 @@ public void CanQueryWithContainsOnTestEnum_Small_1() using (var session = OpenSession()) using (var trans = session.BeginTransaction()) { - var query = session.Query().Where(x => values.Contains(x.Enum)).ToList(); + var query = session.Query().Where(x => values.Contains(x.Enum1)).ToList(); Assert.AreEqual(5, query.Count); } @@ -132,17 +131,17 @@ public void ConditionalNavigationProperty() using (var trans = session.BeginTransaction()) { var entities = session.Query(); - entities.Where(o => o.Enum == TestEnum.Large).ToList(); - entities.Where(o => TestEnum.Large != o.Enum).ToList(); - entities.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToList(); - entities.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToList(); - - entities.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToList(); - entities.Where(o => (o.Enum != TestEnum.Large - ? (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) + entities.Where(o => o.Enum1 == TestEnum.Large).ToList(); + entities.Where(o => TestEnum.Large != o.Enum1).ToList(); + entities.Where(o => (o.NullableEnum1 ?? TestEnum.Large) == TestEnum.Medium).ToList(); + entities.Where(o => ((o.NullableEnum1 ?? type) ?? o.Enum1) == TestEnum.Medium).ToList(); + + entities.Where(o => (o.NullableEnum1.HasValue ? o.Enum1 : TestEnum.Unspecified) == TestEnum.Medium).ToList(); + entities.Where(o => (o.Enum1 != TestEnum.Large + ? (o.NullableEnum1.HasValue ? o.Enum1 : TestEnum.Unspecified) : TestEnum.Small) == TestEnum.Medium).ToList(); - entities.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToList(); + entities.Where(o => (o.Enum1 == TestEnum.Large ? o.Other : o.Other).Name == "test").ToList(); } } @@ -157,59 +156,59 @@ public void CanQueryComplexExpressionOnTestEnum() var entities = session.Query(); var query = (from user in entities - where (user.NullableEnum == TestEnum.Large + where (user.NullableEnum1 == TestEnum.Large ? TestEnum.Medium - : user.NullableEnum ?? user.Enum + : user.NullableEnum1 ?? user.Enum1 ) == type select new { user, - simple = user.Enum, - condition = user.Enum == TestEnum.Large ? TestEnum.Medium : user.Enum, - coalesce = user.NullableEnum ?? TestEnum.Medium + simple = user.Enum1, + condition = user.Enum1 == TestEnum.Large ? TestEnum.Medium : user.Enum1, + coalesce = user.NullableEnum1 ?? TestEnum.Medium }).ToList(); Assert.That(query.Count, Is.EqualTo(0)); } } + } - public class EnumEntity - { - public virtual int Id { get; set; } - public virtual string Name { get; set; } + public class EnumEntity + { + public virtual Guid Id { get; set; } + public virtual string Name { get; set; } - public virtual TestEnum Enum { get; set; } - public virtual TestEnum? NullableEnum { get; set; } + public virtual TestEnum Enum1 { get; set; } + public virtual TestEnum? NullableEnum1 { get; set; } - public virtual EnumEntity Other { get; set; } - } + public virtual EnumEntity Other { get; set; } + } - public enum TestEnum + public enum TestEnum + { + Unspecified, + Small, + Medium, + Large + } + + [Serializable] + public class EnumAnsiStringType : EnumStringType + { + private readonly string typeName; + + public EnumAnsiStringType() + : base(typeof(T)) { - Unspecified, - Small, - Medium, - Large + System.Type type = GetType(); + typeName = type.FullName + ", " + type.Assembly.GetName().Name; } - [Serializable] - public class EnumAnsiStringType : EnumStringType + public override string Name { - private readonly string typeName; - - public EnumAnsiStringType() - : base(typeof(T)) - { - System.Type type = GetType(); - typeName = type.FullName + ", " + type.Assembly.GetName().Name; - } - - public override string Name - { - get { return typeName; } - } - - public override SqlType SqlType => SqlTypeFactory.GetAnsiString(255); + get { return typeName; } } + + public override SqlType SqlType => SqlTypeFactory.GetAnsiString(255); } }