Skip to content

Commit ea56cbc

Browse files
gliljasbahusoid
gliljas
and
bahusoid
authored
Fix cast operation failing when an enum is mapped as an AnsiString (#2499)
* Modified Linq Enum unit tests to test alternate mappings Co-authored-by: Roman Artiukhin <[email protected]>
1 parent f43dc6d commit ea56cbc

File tree

4 files changed

+321
-112
lines changed

4 files changed

+321
-112
lines changed

‎src/NHibernate.Test/Async/Linq/EnumTests.cs

Lines changed: 133 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -8,103 +8,181 @@
88
//------------------------------------------------------------------------------
99

1010

11+
using System;
1112
using System.Linq;
12-
using NHibernate.DomainModel.Northwind.Entities;
13+
using NHibernate.Cfg.MappingSchema;
14+
using NHibernate.Mapping.ByCode;
15+
using NHibernate.SqlTypes;
16+
using NHibernate.Type;
1317
using NUnit.Framework;
1418
using NHibernate.Linq;
1519

1620
namespace NHibernate.Test.Linq
1721
{
1822
using System.Threading.Tasks;
1923
using System.Threading;
20-
[TestFixture]
21-
public class EnumTestsAsync : LinqTestCase
24+
[TestFixture(typeof(EnumType<TestEnum>), "0")]
25+
[TestFixture(typeof(EnumStringType<TestEnum>), "'Unspecified'")]
26+
[TestFixture(typeof(EnumAnsiStringType<TestEnum>), "'Unspecified'")]
27+
public class EnumTestsAsync : TestCaseMappingByCode
2228
{
23-
[Test]
24-
public async Task CanQueryOnEnumStoredAsInt32_High_1Async()
29+
private IType _enumType;
30+
private string _unspecifiedValue;
31+
32+
public EnumTestsAsync(System.Type enumType, string unspecifiedValue)
2533
{
26-
await (CanQueryOnEnumStoredAsInt32Async(EnumStoredAsInt32.High, 1));
34+
_enumType = (IType) Activator.CreateInstance(enumType);
35+
_unspecifiedValue = unspecifiedValue;
2736
}
2837

29-
[Test]
30-
public async Task CanQueryOnEnumStoredAsInt32_Unspecified_2Async()
38+
protected override HbmMapping GetMappings()
3139
{
32-
await (CanQueryOnEnumStoredAsInt32Async(EnumStoredAsInt32.Unspecified, 2));
40+
var mapper = new ModelMapper();
41+
mapper.Class<EnumEntity>(
42+
rc =>
43+
{
44+
rc.Table("EnumEntity");
45+
rc.Id(x => x.Id, m => m.Generator(Generators.Guid));
46+
rc.Property(x => x.Name);
47+
rc.Property(x => x.Enum1, m => m.Type(_enumType));
48+
rc.Property(x => x.NullableEnum1, m =>
49+
{
50+
m.Type(_enumType);
51+
m.Formula($"(case when Enum1 = {_unspecifiedValue} then null else Enum1 end)");
52+
});
53+
rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All));
54+
});
55+
56+
return mapper.CompileMappingForAllExplicitlyAddedEntities();
3357
}
3458

35-
public async Task CanQueryOnEnumStoredAsInt32Async(EnumStoredAsInt32 type, int expectedCount, CancellationToken cancellationToken = default(CancellationToken))
59+
protected override void OnSetUp()
3660
{
37-
var query = await ((from user in db.Users
38-
where user.Enum2 == type
39-
select user).ToListAsync(cancellationToken));
61+
base.OnSetUp();
62+
using (var session = OpenSession())
63+
using (var trans = session.BeginTransaction())
64+
{
65+
session.Save(new EnumEntity { Enum1 = TestEnum.Unspecified });
66+
session.Save(new EnumEntity { Enum1 = TestEnum.Small });
67+
session.Save(new EnumEntity { Enum1 = TestEnum.Small });
68+
session.Save(new EnumEntity { Enum1 = TestEnum.Medium });
69+
session.Save(new EnumEntity { Enum1 = TestEnum.Medium });
70+
session.Save(new EnumEntity { Enum1 = TestEnum.Medium });
71+
session.Save(new EnumEntity { Enum1 = TestEnum.Large });
72+
session.Save(new EnumEntity { Enum1 = TestEnum.Large });
73+
session.Save(new EnumEntity { Enum1 = TestEnum.Large });
74+
session.Save(new EnumEntity { Enum1 = TestEnum.Large });
75+
trans.Commit();
76+
}
77+
}
78+
79+
protected override void OnTearDown()
80+
{
81+
using (var session = OpenSession())
82+
using (var transaction = session.BeginTransaction())
83+
{
84+
session.Delete("from System.Object");
85+
86+
session.Flush();
87+
transaction.Commit();
88+
}
89+
}
4090

41-
Assert.AreEqual(expectedCount, query.Count);
91+
[Test]
92+
public async Task CanQueryOnEnum_Large_4Async()
93+
{
94+
await (CanQueryOnEnumAsync(TestEnum.Large, 4));
95+
}
96+
97+
[Test]
98+
public async Task CanQueryOnEnum_Medium_3Async()
99+
{
100+
await (CanQueryOnEnumAsync(TestEnum.Medium, 3));
42101
}
43102

44103
[Test]
45-
public async Task CanQueryOnEnumStoredAsString_Meduim_2Async()
104+
public async Task CanQueryOnEnum_Small_2Async()
46105
{
47-
await (CanQueryOnEnumStoredAsStringAsync(EnumStoredAsString.Medium, 2));
106+
await (CanQueryOnEnumAsync(TestEnum.Small, 2));
48107
}
49108

50109
[Test]
51-
public async Task CanQueryOnEnumStoredAsString_Small_1Async()
110+
public async Task CanQueryOnEnum_Unspecified_1Async()
52111
{
53-
await (CanQueryOnEnumStoredAsStringAsync(EnumStoredAsString.Small, 1));
112+
await (CanQueryOnEnumAsync(TestEnum.Unspecified, 1));
54113
}
55114

56-
public async Task CanQueryOnEnumStoredAsStringAsync(EnumStoredAsString type, int expectedCount, CancellationToken cancellationToken = default(CancellationToken))
115+
private async Task CanQueryOnEnumAsync(TestEnum type, int expectedCount, CancellationToken cancellationToken = default(CancellationToken))
57116
{
58-
var query = await ((from user in db.Users
59-
where user.Enum1 == type
60-
select user).ToListAsync(cancellationToken));
117+
using (var session = OpenSession())
118+
using (var trans = session.BeginTransaction())
119+
{
120+
var query = await (session.Query<EnumEntity>().Where(x => x.Enum1 == type).ToListAsync(cancellationToken));
61121

62-
Assert.AreEqual(expectedCount, query.Count);
122+
Assert.AreEqual(expectedCount, query.Count);
123+
}
63124
}
64125

65126
[Test]
66-
public async Task CanQueryWithContainsOnEnumStoredAsString_Small_1Async()
127+
public async Task CanQueryWithContainsOnTestEnum_Small_1Async()
67128
{
68-
var values = new[] { EnumStoredAsString.Small, EnumStoredAsString.Medium };
69-
var query = await (db.Users.Where(x => values.Contains(x.Enum1)).ToListAsync());
70-
Assert.AreEqual(3, query.Count);
129+
var values = new[] { TestEnum.Small, TestEnum.Medium };
130+
using (var session = OpenSession())
131+
using (var trans = session.BeginTransaction())
132+
{
133+
var query = await (session.Query<EnumEntity>().Where(x => values.Contains(x.Enum1)).ToListAsync());
134+
135+
Assert.AreEqual(5, query.Count);
136+
}
71137
}
72138

73139
[Test]
74140
public async Task ConditionalNavigationPropertyAsync()
75141
{
76-
EnumStoredAsString? type = null;
77-
await (db.Users.Where(o => o.Enum1 == EnumStoredAsString.Large).ToListAsync());
78-
await (db.Users.Where(o => EnumStoredAsString.Large != o.Enum1).ToListAsync());
79-
await (db.Users.Where(o => (o.NullableEnum1 ?? EnumStoredAsString.Large) == EnumStoredAsString.Medium).ToListAsync());
80-
await (db.Users.Where(o => ((o.NullableEnum1 ?? type) ?? o.Enum1) == EnumStoredAsString.Medium).ToListAsync());
81-
82-
await (db.Users.Where(o => (o.NullableEnum1.HasValue ? o.Enum1 : EnumStoredAsString.Unspecified) == EnumStoredAsString.Medium).ToListAsync());
83-
await (db.Users.Where(o => (o.Enum1 != EnumStoredAsString.Large
84-
? (o.NullableEnum1.HasValue ? o.Enum1 : EnumStoredAsString.Unspecified)
85-
: EnumStoredAsString.Small) == EnumStoredAsString.Medium).ToListAsync());
86-
87-
await (db.Users.Where(o => (o.Enum1 == EnumStoredAsString.Large ? o.Role : o.Role).Name == "test").ToListAsync());
142+
TestEnum? type = null;
143+
using (var session = OpenSession())
144+
using (var trans = session.BeginTransaction())
145+
{
146+
var entities = session.Query<EnumEntity>();
147+
await (entities.Where(o => o.Enum1 == TestEnum.Large).ToListAsync());
148+
await (entities.Where(o => TestEnum.Large != o.Enum1).ToListAsync());
149+
await (entities.Where(o => (o.NullableEnum1 ?? TestEnum.Large) == TestEnum.Medium).ToListAsync());
150+
await (entities.Where(o => ((o.NullableEnum1 ?? type) ?? o.Enum1) == TestEnum.Medium).ToListAsync());
151+
152+
await (entities.Where(o => (o.NullableEnum1.HasValue ? o.Enum1 : TestEnum.Unspecified) == TestEnum.Medium).ToListAsync());
153+
await (entities.Where(o => (o.Enum1 != TestEnum.Large
154+
? (o.NullableEnum1.HasValue ? o.Enum1 : TestEnum.Unspecified)
155+
: TestEnum.Small) == TestEnum.Medium).ToListAsync());
156+
157+
await (entities.Where(o => (o.Enum1 == TestEnum.Large ? o.Other : o.Other).Name == "test").ToListAsync());
158+
}
88159
}
89160

90161
[Test]
91-
public async Task CanQueryComplexExpressionOnEnumStoredAsStringAsync()
162+
public async Task CanQueryComplexExpressionOnTestEnumAsync()
92163
{
93-
var type = EnumStoredAsString.Unspecified;
94-
var query = await ((from user in db.Users
95-
where (user.NullableEnum1 == EnumStoredAsString.Large
96-
? EnumStoredAsString.Medium
97-
: user.NullableEnum1 ?? user.Enum1
98-
) == type
99-
select new
100-
{
101-
user,
102-
simple = user.Enum1,
103-
condition = user.Enum1 == EnumStoredAsString.Large ? EnumStoredAsString.Medium : user.Enum1,
104-
coalesce = user.NullableEnum1 ?? EnumStoredAsString.Medium
105-
}).ToListAsync());
106-
107-
Assert.That(query.Count, Is.EqualTo(0));
164+
//TODO: Fix issue on SQLite with type set to TestEnum.Unspecified
165+
TestEnum? type = null;
166+
using (var session = OpenSession())
167+
using (var trans = session.BeginTransaction())
168+
{
169+
var entities = session.Query<EnumEntity>();
170+
171+
var query = await ((from user in entities
172+
where (user.NullableEnum1 == TestEnum.Large
173+
? TestEnum.Medium
174+
: user.NullableEnum1 ?? user.Enum1
175+
) == type
176+
select new
177+
{
178+
user,
179+
simple = user.Enum1,
180+
condition = user.Enum1 == TestEnum.Large ? TestEnum.Medium : user.Enum1,
181+
coalesce = user.NullableEnum1 ?? TestEnum.Medium
182+
}).ToListAsync());
183+
184+
Assert.That(query.Count, Is.EqualTo(0));
185+
}
108186
}
109187
}
110188
}

0 commit comments

Comments
 (0)