Skip to content

Commit 5a90a74

Browse files
hazzikhazzik
committed
Async regen
1 parent 5642743 commit 5a90a74

File tree

1 file changed

+167
-55
lines changed

1 file changed

+167
-55
lines changed

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

Lines changed: 167 additions & 55 deletions
Original file line numberDiff line numberDiff line change
@@ -8,103 +8,215 @@
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>))]
25+
[TestFixture(typeof(EnumStringType<TestEnum>))]
26+
[TestFixture(typeof(EnumAnsiStringType<TestEnum>))]
27+
public class EnumTestsAsync : TestCaseMappingByCode
2228
{
23-
[Test]
24-
public async Task CanQueryOnEnumStoredAsInt32_High_1Async()
29+
private IType _enumType;
30+
31+
32+
public EnumTestsAsync(System.Type enumType)
2533
{
26-
await (CanQueryOnEnumStoredAsInt32Async(EnumStoredAsInt32.High, 1));
34+
_enumType = (IType) Activator.CreateInstance(enumType);
2735
}
2836

29-
[Test]
30-
public async Task CanQueryOnEnumStoredAsInt32_Unspecified_2Async()
37+
protected override HbmMapping GetMappings()
38+
{
39+
var mapper = new ModelMapper();
40+
mapper.Class<EnumEntity>(
41+
rc =>
42+
{
43+
rc.Table("EnumEntity");
44+
rc.Id(x => x.Id, m => m.Generator(Generators.Identity));
45+
rc.Property(x => x.Name);
46+
rc.Property(x => x.Enum, m => m.Type(_enumType));
47+
rc.Property(x => x.NullableEnum, m => m.Type(_enumType));
48+
rc.ManyToOne(x => x.Other, m => m.Cascade(Mapping.ByCode.Cascade.All));
49+
});
50+
51+
52+
return mapper.CompileMappingForAllExplicitlyAddedEntities();
53+
}
54+
55+
protected override void OnSetUp()
3156
{
32-
await (CanQueryOnEnumStoredAsInt32Async(EnumStoredAsInt32.Unspecified, 2));
57+
base.OnSetUp();
58+
using (var session = OpenSession())
59+
using (var trans = session.BeginTransaction())
60+
{
61+
session.Save(new EnumEntity { Enum = TestEnum.Unspecified });
62+
session.Save(new EnumEntity { Enum = TestEnum.Small });
63+
session.Save(new EnumEntity { Enum = TestEnum.Small });
64+
session.Save(new EnumEntity { Enum = TestEnum.Medium });
65+
session.Save(new EnumEntity { Enum = TestEnum.Medium });
66+
session.Save(new EnumEntity { Enum = TestEnum.Medium });
67+
session.Save(new EnumEntity { Enum = TestEnum.Large });
68+
session.Save(new EnumEntity { Enum = TestEnum.Large });
69+
session.Save(new EnumEntity { Enum = TestEnum.Large });
70+
session.Save(new EnumEntity { Enum = TestEnum.Large });
71+
trans.Commit();
72+
}
3373
}
3474

35-
public async Task CanQueryOnEnumStoredAsInt32Async(EnumStoredAsInt32 type, int expectedCount, CancellationToken cancellationToken = default(CancellationToken))
75+
protected override void OnTearDown()
3676
{
37-
var query = await ((from user in db.Users
38-
where user.Enum2 == type
39-
select user).ToListAsync(cancellationToken));
77+
using (var session = OpenSession())
78+
using (var transaction = session.BeginTransaction())
79+
{
80+
session.Delete("from System.Object");
81+
82+
session.Flush();
83+
transaction.Commit();
84+
}
85+
}
4086

41-
Assert.AreEqual(expectedCount, query.Count);
87+
[Test]
88+
public async Task CanQueryOnEnum_Large_4Async()
89+
{
90+
await (CanQueryOnEnumAsync(TestEnum.Large, 4));
91+
}
92+
93+
[Test]
94+
public async Task CanQueryOnEnum_Medium_3Async()
95+
{
96+
await (CanQueryOnEnumAsync(TestEnum.Medium, 3));
4297
}
4398

4499
[Test]
45-
public async Task CanQueryOnEnumStoredAsString_Meduim_2Async()
100+
public async Task CanQueryOnEnum_Small_2Async()
46101
{
47-
await (CanQueryOnEnumStoredAsStringAsync(EnumStoredAsString.Medium, 2));
102+
await (CanQueryOnEnumAsync(TestEnum.Small, 2));
48103
}
49104

50105
[Test]
51-
public async Task CanQueryOnEnumStoredAsString_Small_1Async()
106+
public async Task CanQueryOnEnum_Unspecified_1Async()
52107
{
53-
await (CanQueryOnEnumStoredAsStringAsync(EnumStoredAsString.Small, 1));
108+
await (CanQueryOnEnumAsync(TestEnum.Unspecified, 1));
54109
}
55110

56-
public async Task CanQueryOnEnumStoredAsStringAsync(EnumStoredAsString type, int expectedCount, CancellationToken cancellationToken = default(CancellationToken))
111+
private async Task CanQueryOnEnumAsync(TestEnum type, int expectedCount, CancellationToken cancellationToken = default(CancellationToken))
57112
{
58-
var query = await ((from user in db.Users
59-
where user.Enum1 == type
60-
select user).ToListAsync(cancellationToken));
113+
using (var session = OpenSession())
114+
using (var trans = session.BeginTransaction())
115+
{
116+
var query = await (session.Query<EnumEntity>().Where(x => x.Enum == type).ToListAsync(cancellationToken));
61117

62-
Assert.AreEqual(expectedCount, query.Count);
118+
Assert.AreEqual(expectedCount, query.Count);
119+
}
63120
}
64121

65122
[Test]
66-
public async Task CanQueryWithContainsOnEnumStoredAsString_Small_1Async()
123+
public async Task CanQueryWithContainsOnTestEnum_Small_1Async()
67124
{
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);
125+
var values = new[] { TestEnum.Small, TestEnum.Medium };
126+
using (var session = OpenSession())
127+
using (var trans = session.BeginTransaction())
128+
{
129+
var query = await (session.Query<EnumEntity>().Where(x => values.Contains(x.Enum)).ToListAsync());
130+
131+
Assert.AreEqual(5, query.Count);
132+
}
71133
}
72134

73135
[Test]
74136
public async Task ConditionalNavigationPropertyAsync()
75137
{
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());
138+
TestEnum? type = null;
139+
using (var session = OpenSession())
140+
using (var trans = session.BeginTransaction())
141+
{
142+
var entities = session.Query<EnumEntity>();
143+
await (entities.Where(o => o.Enum == TestEnum.Large).ToListAsync());
144+
await (entities.Where(o => TestEnum.Large != o.Enum).ToListAsync());
145+
await (entities.Where(o => (o.NullableEnum ?? TestEnum.Large) == TestEnum.Medium).ToListAsync());
146+
await (entities.Where(o => ((o.NullableEnum ?? type) ?? o.Enum) == TestEnum.Medium).ToListAsync());
147+
148+
await (entities.Where(o => (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified) == TestEnum.Medium).ToListAsync());
149+
await (entities.Where(o => (o.Enum != TestEnum.Large
150+
? (o.NullableEnum.HasValue ? o.Enum : TestEnum.Unspecified)
151+
: TestEnum.Small) == TestEnum.Medium).ToListAsync());
152+
153+
await (entities.Where(o => (o.Enum == TestEnum.Large ? o.Other : o.Other).Name == "test").ToListAsync());
154+
}
88155
}
89156

90157
[Test]
91-
public async Task CanQueryComplexExpressionOnEnumStoredAsStringAsync()
158+
public async Task CanQueryComplexExpressionOnTestEnumAsync()
92159
{
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));
160+
var type = TestEnum.Unspecified;
161+
using (var session = OpenSession())
162+
using (var trans = session.BeginTransaction())
163+
{
164+
var entities = session.Query<EnumEntity>();
165+
166+
var query = await ((from user in entities
167+
where (user.NullableEnum == TestEnum.Large
168+
? TestEnum.Medium
169+
: user.NullableEnum ?? user.Enum
170+
) == type
171+
select new
172+
{
173+
user,
174+
simple = user.Enum,
175+
condition = user.Enum == TestEnum.Large ? TestEnum.Medium : user.Enum,
176+
coalesce = user.NullableEnum ?? TestEnum.Medium
177+
}).ToListAsync());
178+
179+
Assert.That(query.Count, Is.EqualTo(1));
180+
}
181+
}
182+
183+
public class EnumEntity
184+
{
185+
public virtual int Id { get; set; }
186+
public virtual string Name { get; set; }
187+
188+
public virtual TestEnum Enum { get; set; }
189+
public virtual TestEnum? NullableEnum { get; set; }
190+
191+
public virtual EnumEntity Other { get; set; }
192+
}
193+
194+
public enum TestEnum
195+
{
196+
Unspecified,
197+
Small,
198+
Medium,
199+
Large
200+
}
201+
202+
[Serializable]
203+
public class EnumAnsiStringType<T> : EnumStringType
204+
{
205+
private readonly string typeName;
206+
207+
public EnumAnsiStringType()
208+
: base(typeof(T))
209+
{
210+
System.Type type = GetType();
211+
typeName = type.FullName + ", " + type.Assembly.GetName().Name;
212+
}
213+
214+
public override string Name
215+
{
216+
get { return typeName; }
217+
}
218+
219+
public override SqlType SqlType => SqlTypeFactory.GetAnsiString(255);
108220
}
109221
}
110222
}

0 commit comments

Comments
 (0)