Skip to content

Commit fe69cac

Browse files
fredericDelaportefredericDelaporte
committed
Do some cleanup
1 parent 8cc7303 commit fe69cac

File tree

7 files changed

+73
-84
lines changed

7 files changed

+73
-84
lines changed

‎src/NHibernate.Test/Async/Criteria/ReadonlyTests/QueryOverCacheableTests.cs‎

Lines changed: 19 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -23,11 +23,11 @@ public class QueryOverCacheableTestsAsync : CriteriaNorthwindReadonlyTestCase
2323
//Just for discoverability
2424
private class CriteriaCacheableTest{}
2525

26-
protected override void Configure(Configuration cfg)
26+
protected override void Configure(Configuration config)
2727
{
28-
cfg.SetProperty(Environment.UseQueryCache, "true");
29-
cfg.SetProperty(Environment.GenerateStatistics, "true");
30-
base.Configure(cfg);
28+
config.SetProperty(Environment.UseQueryCache, "true");
29+
config.SetProperty(Environment.GenerateStatistics, "true");
30+
base.Configure(config);
3131
}
3232

3333
[Test]
@@ -36,8 +36,8 @@ public async Task QueryIsCacheableAsync()
3636
Sfi.Statistics.Clear();
3737
await (Sfi.EvictQueriesAsync());
3838

39-
var x = await (db.Customers.Cacheable().Take(1).ListAsync());
40-
var x2 = await (db.Customers.Cacheable().Take(1).ListAsync());
39+
await (db.Customers.Cacheable().Take(1).ListAsync());
40+
await (db.Customers.Cacheable().Take(1).ListAsync());
4141

4242
Assert.That(Sfi.Statistics.QueryExecutionCount, Is.EqualTo(1), "Unexpected execution count");
4343
Assert.That(Sfi.Statistics.QueryCachePutCount, Is.EqualTo(1), "Unexpected cache put count");
@@ -50,8 +50,8 @@ public async Task QueryIsCacheable2Async()
5050
Sfi.Statistics.Clear();
5151
await (Sfi.EvictQueriesAsync());
5252

53-
var x = await (db.Customers.Cacheable().Take(1).ListAsync());
54-
var x2 = await (db.Customers.Take(1).ListAsync());
53+
await (db.Customers.Cacheable().Take(1).ListAsync());
54+
await (db.Customers.Take(1).ListAsync());
5555

5656
Assert.That(Sfi.Statistics.QueryExecutionCount, Is.EqualTo(2), "Unexpected execution count");
5757
Assert.That(Sfi.Statistics.QueryCachePutCount, Is.EqualTo(1), "Unexpected cache put count");
@@ -66,20 +66,18 @@ public async Task QueryIsCacheableWithRegionAsync()
6666
await (Sfi.EvictQueriesAsync("test"));
6767
await (Sfi.EvictQueriesAsync("other"));
6868

69-
var x = await (db.Customers.Cacheable().Take(1).CacheRegion("test").ListAsync());
70-
var x2 = await (db.Customers.Cacheable().Take(1).CacheRegion("test").ListAsync());
71-
var x3 = await (db.Customers.Cacheable().Take(1).CacheRegion("other").ListAsync());
69+
await (db.Customers.Cacheable().Take(1).CacheRegion("test").ListAsync());
70+
await (db.Customers.Cacheable().Take(1).CacheRegion("test").ListAsync());
71+
await (db.Customers.Cacheable().Take(1).CacheRegion("other").ListAsync());
7272

7373
Assert.That(Sfi.Statistics.QueryExecutionCount, Is.EqualTo(2), "Unexpected execution count");
7474
Assert.That(Sfi.Statistics.QueryCachePutCount, Is.EqualTo(2), "Unexpected cache put count");
7575
Assert.That(Sfi.Statistics.QueryCacheHitCount, Is.EqualTo(1), "Unexpected cache hit count");
7676
}
7777

78-
7978
[Test]
8079
public async Task CanBeCombinedWithFetchAsync()
8180
{
82-
8381
Sfi.Statistics.Clear();
8482
await (Sfi.EvictQueriesAsync());
8583

@@ -104,13 +102,13 @@ public async Task CanBeCombinedWithFetchAsync()
104102
.Take(1)
105103
.ListAsync());
106104

107-
var customer = await (db.Customers
105+
await (db.Customers
108106
.Fetch(SelectMode.Fetch, x => x.Address)
109107
.Where(x => x.CustomerId == "VINET")
110108
.Cacheable()
111109
.SingleOrDefaultAsync());
112110

113-
customer = await (db.Customers
111+
var customer = await (db.Customers
114112
.Fetch(SelectMode.Fetch, x => x.Address)
115113
.Where(x => x.CustomerId == "VINET")
116114
.Cacheable()
@@ -128,8 +126,7 @@ public async Task FetchIsCacheableAsync()
128126
Sfi.Statistics.Clear();
129127
await (Sfi.EvictQueriesAsync());
130128

131-
Order order;
132-
order = (await (db.Orders
129+
var order = (await (db.Orders
133130
.Fetch(
134131
SelectMode.Fetch,
135132
x => x.Customer,
@@ -170,20 +167,18 @@ public async Task FetchIsCacheableAsync()
170167
Assert.That(Sfi.Statistics.QueryCacheHitCount, Is.EqualTo(1), "Unexpected cache hit count");
171168
}
172169

173-
174170
[Test]
175171
public async Task FetchIsCacheableForJoinAliasAsync()
176172
{
177173
Sfi.Statistics.Clear();
178174
await (Sfi.EvictQueriesAsync());
179175

180-
Order order;
181176
Customer customer = null;
182177
OrderLine orderLines = null;
183178
Product product = null;
184179
OrderLine prOrderLines = null;
185-
186-
order = (await (db.Orders
180+
181+
var order = (await (db.Orders
187182
.JoinAlias(x => x.Customer, () => customer)
188183
.JoinAlias(x => x.OrderLines, () => orderLines, JoinType.LeftOuterJoin)
189184
.JoinAlias(() => orderLines.Product, () => product)
@@ -227,15 +222,13 @@ public async Task FutureFetchIsCacheableAsync()
227222
await (Sfi.EvictQueriesAsync());
228223
var multiQueries = Sfi.ConnectionProvider.Driver.SupportsMultipleQueries;
229224

230-
Order order;
231-
232225
db.Orders
233226
.Fetch(SelectMode.Fetch, x => x.Customer)
234227
.Where(x => x.OrderId == 10248)
235228
.Cacheable()
236229
.Future();
237230

238-
order = db.Orders
231+
var order = db.Orders
239232
.Fetch(
240233
SelectMode.Fetch,
241234
x => x.OrderLines,
@@ -284,12 +277,12 @@ public async Task FutureFetchIsCacheableAsync()
284277

285278
private static void AssertFetchedOrder(Order order)
286279
{
287-
Assert.That(order.Customer, Is.Not.Null, "Expected the fetched Customer to be initialized");
280+
Assert.That(order.Customer, Is.Not.Null, "Expected the fetched Customer to be not null");
288281
Assert.That(NHibernateUtil.IsInitialized(order.Customer), Is.True, "Expected the fetched Customer to be initialized");
289282
Assert.That(NHibernateUtil.IsInitialized(order.OrderLines), Is.True, "Expected the fetched OrderLines to be initialized");
290283
Assert.That(order.OrderLines, Has.Count.EqualTo(3), "Expected the fetched OrderLines to have 3 items");
291284
var orderLine = order.OrderLines.First();
292-
Assert.That(orderLine.Product, Is.Not.Null, "Expected the fetched Product to be initialized");
285+
Assert.That(orderLine.Product, Is.Not.Null, "Expected the fetched Product to be not null");
293286
Assert.That(NHibernateUtil.IsInitialized(orderLine.Product), Is.True, "Expected the fetched Product to be initialized");
294287
Assert.That(NHibernateUtil.IsInitialized(orderLine.Product.OrderLines), Is.True, "Expected the fetched OrderLines to be initialized");
295288
}

‎src/NHibernate.Test/Async/Hql/EntityJoinHqlTest.cs‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -497,7 +497,7 @@ protected override HbmMapping GetMappings()
497497
{
498498
rc.Id(e => e.Id, m => m.Generator(Generators.GuidComb));
499499
rc.Property(e => e.Name);
500-
rc.Property(e => e.PropertyRef);
500+
rc.Property(e => e.PropertyRef, m => m.Column("EntityPropertyRef"));
501501
});
502502

503503
mapper.Class<NullableOwner>(
@@ -510,6 +510,7 @@ protected override HbmMapping GetMappings()
510510
e => e.PropRef,
511511
m =>
512512
{
513+
m.Column("OwnerPropertyRef");
513514
m.PropertyRef(nameof(PropRefEntity.PropertyRef));
514515
m.ForeignKey("none");
515516
m.NotFound(NotFoundMode.Ignore);

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

Lines changed: 16 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -417,13 +417,14 @@ public async Task ProjectedEntitiesAreCachableAsync()
417417
var dto = await (session.Query<Order>()
418418
.WithOptions(o => o.SetCacheable(true))
419419
.Where(x => x.OrderId == 10248)
420-
.Select(x => new {Customer = x.Customer, Order = x})
420+
.Select(x => new { x.Customer, Order = x })
421421
.FirstOrDefaultAsync());
422422

423-
Assert.That(dto.Order, Is.Not.Null);
424-
Assert.That(NHibernateUtil.IsInitialized(dto.Order), Is.True);
425-
Assert.That(dto.Customer, Is.Not.Null);
426-
Assert.That(NHibernateUtil.IsInitialized(dto.Customer), Is.True);
423+
Assert.That(dto, Is.Not.Null, "dto should not be null");
424+
Assert.That(dto.Order, Is.Not.Null, "dto.Order should not be null");
425+
Assert.That(NHibernateUtil.IsInitialized(dto.Order), Is.True, "dto.Order should be initialized");
426+
Assert.That(dto.Customer, Is.Not.Null, "dto.Customer should not be null");
427+
Assert.That(NHibernateUtil.IsInitialized(dto.Customer), Is.True, "dto.Customer from cache should be initialized");
427428

428429
Assert.That(Sfi.Statistics.QueryExecutionCount, Is.EqualTo(1), "Unexpected execution count");
429430
Assert.That(Sfi.Statistics.QueryCachePutCount, Is.EqualTo(1), "Unexpected cache put count");
@@ -435,13 +436,14 @@ public async Task ProjectedEntitiesAreCachableAsync()
435436
dto = await (session.Query<Order>()
436437
.WithOptions(o => o.SetCacheable(true))
437438
.Where(x => x.OrderId == 10248)
438-
.Select(x => new {Customer = x.Customer, Order = x})
439+
.Select(x => new { x.Customer, Order = x })
439440
.FirstOrDefaultAsync());
440441

441-
Assert.That(dto.Order, Is.Not.Null);
442-
Assert.That(NHibernateUtil.IsInitialized(dto.Order), Is.True);
443-
Assert.That(dto.Customer, Is.Not.Null);
444-
Assert.That(NHibernateUtil.IsInitialized(dto.Customer), Is.True);
442+
Assert.That(dto, Is.Not.Null, "dto from cache should not be null");
443+
Assert.That(dto.Order, Is.Not.Null, "dto.Order from cache should not be null");
444+
Assert.That(NHibernateUtil.IsInitialized(dto.Order), Is.True, "dto.Order from cache should be initialized");
445+
Assert.That(dto.Customer, Is.Not.Null, "dto.Customer from cache should not be null");
446+
Assert.That(NHibernateUtil.IsInitialized(dto.Customer), Is.True, "dto.Customer from cache should be initialized");
445447

446448
Assert.That(Sfi.Statistics.QueryExecutionCount, Is.EqualTo(0), "Unexpected execution count");
447449
Assert.That(Sfi.Statistics.QueryCachePutCount, Is.EqualTo(0), "Unexpected cache put count");
@@ -457,12 +459,11 @@ public async Task CacheHqlQueryWithFetchAndTransformerThatChangeTupleAsync()
457459

458460
Sfi.Statistics.Clear();
459461
await (Sfi.EvictQueriesAsync());
460-
Order order;
461462

462463
// the combination of query and transformer doesn't make sense.
463464
// It's simply used as example of returned data being transformed before caching leading to mismatch between
464465
// Loader.ResultTypes collection and provided tuple
465-
order = await (session.CreateQuery("select o.Employee.FirstName, o from Order o join fetch o.Customer where o.OrderId = :id")
466+
var order = await (session.CreateQuery("select o.Employee.FirstName, o from Order o join fetch o.Customer where o.OrderId = :id")
466467
.SetInt32("id", 10248)
467468
.SetCacheable(true)
468469
.SetResultTransformer(Transformers.RootEntity)
@@ -495,13 +496,13 @@ public async Task CacheHqlQueryWithFetchAndTransformerThatChangeTupleAsync()
495496

496497
private static void AssertFetchedOrder(Order order)
497498
{
498-
Assert.That(NHibernateUtil.IsInitialized(order));
499-
Assert.That(order.Customer, Is.Not.Null, "Expected the fetched Customer to be initialized");
499+
Assert.That(NHibernateUtil.IsInitialized(order), "Expected the order to be initialized");
500+
Assert.That(order.Customer, Is.Not.Null, "Expected the fetched Customer to be not null");
500501
Assert.That(NHibernateUtil.IsInitialized(order.Customer), Is.True, "Expected the fetched Customer to be initialized");
501502
Assert.That(NHibernateUtil.IsInitialized(order.OrderLines), Is.True, "Expected the fetched OrderLines to be initialized");
502503
Assert.That(order.OrderLines, Has.Count.EqualTo(3), "Expected the fetched OrderLines to have 3 items");
503504
var orderLine = order.OrderLines.First();
504-
Assert.That(orderLine.Product, Is.Not.Null, "Expected the fetched Product to be initialized");
505+
Assert.That(orderLine.Product, Is.Not.Null, "Expected the fetched Product to be not null");
505506
Assert.That(NHibernateUtil.IsInitialized(orderLine.Product), Is.True, "Expected the fetched Product to be initialized");
506507
Assert.That(NHibernateUtil.IsInitialized(orderLine.Product.OrderLines), Is.True, "Expected the fetched OrderLines to be initialized");
507508
}

‎src/NHibernate.Test/Criteria/ReadonlyTests/QueryOverCacheableTests.cs‎

Lines changed: 19 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -12,11 +12,11 @@ public class QueryOverCacheableTests : CriteriaNorthwindReadonlyTestCase
1212
//Just for discoverability
1313
private class CriteriaCacheableTest{}
1414

15-
protected override void Configure(Configuration cfg)
15+
protected override void Configure(Configuration config)
1616
{
17-
cfg.SetProperty(Environment.UseQueryCache, "true");
18-
cfg.SetProperty(Environment.GenerateStatistics, "true");
19-
base.Configure(cfg);
17+
config.SetProperty(Environment.UseQueryCache, "true");
18+
config.SetProperty(Environment.GenerateStatistics, "true");
19+
base.Configure(config);
2020
}
2121

2222
[Test]
@@ -25,8 +25,8 @@ public void QueryIsCacheable()
2525
Sfi.Statistics.Clear();
2626
Sfi.EvictQueries();
2727

28-
var x = db.Customers.Cacheable().Take(1).List();
29-
var x2 = db.Customers.Cacheable().Take(1).List();
28+
db.Customers.Cacheable().Take(1).List();
29+
db.Customers.Cacheable().Take(1).List();
3030

3131
Assert.That(Sfi.Statistics.QueryExecutionCount, Is.EqualTo(1), "Unexpected execution count");
3232
Assert.That(Sfi.Statistics.QueryCachePutCount, Is.EqualTo(1), "Unexpected cache put count");
@@ -39,8 +39,8 @@ public void QueryIsCacheable2()
3939
Sfi.Statistics.Clear();
4040
Sfi.EvictQueries();
4141

42-
var x = db.Customers.Cacheable().Take(1).List();
43-
var x2 = db.Customers.Take(1).List();
42+
db.Customers.Cacheable().Take(1).List();
43+
db.Customers.Take(1).List();
4444

4545
Assert.That(Sfi.Statistics.QueryExecutionCount, Is.EqualTo(2), "Unexpected execution count");
4646
Assert.That(Sfi.Statistics.QueryCachePutCount, Is.EqualTo(1), "Unexpected cache put count");
@@ -55,20 +55,18 @@ public void QueryIsCacheableWithRegion()
5555
Sfi.EvictQueries("test");
5656
Sfi.EvictQueries("other");
5757

58-
var x = db.Customers.Cacheable().Take(1).CacheRegion("test").List();
59-
var x2 = db.Customers.Cacheable().Take(1).CacheRegion("test").List();
60-
var x3 = db.Customers.Cacheable().Take(1).CacheRegion("other").List();
58+
db.Customers.Cacheable().Take(1).CacheRegion("test").List();
59+
db.Customers.Cacheable().Take(1).CacheRegion("test").List();
60+
db.Customers.Cacheable().Take(1).CacheRegion("other").List();
6161

6262
Assert.That(Sfi.Statistics.QueryExecutionCount, Is.EqualTo(2), "Unexpected execution count");
6363
Assert.That(Sfi.Statistics.QueryCachePutCount, Is.EqualTo(2), "Unexpected cache put count");
6464
Assert.That(Sfi.Statistics.QueryCacheHitCount, Is.EqualTo(1), "Unexpected cache hit count");
6565
}
6666

67-
6867
[Test]
6968
public void CanBeCombinedWithFetch()
7069
{
71-
7270
Sfi.Statistics.Clear();
7371
Sfi.EvictQueries();
7472

@@ -93,13 +91,13 @@ public void CanBeCombinedWithFetch()
9391
.Take(1)
9492
.List();
9593

96-
var customer = db.Customers
94+
db.Customers
9795
.Fetch(SelectMode.Fetch, x => x.Address)
9896
.Where(x => x.CustomerId == "VINET")
9997
.Cacheable()
10098
.SingleOrDefault();
10199

102-
customer = db.Customers
100+
var customer = db.Customers
103101
.Fetch(SelectMode.Fetch, x => x.Address)
104102
.Where(x => x.CustomerId == "VINET")
105103
.Cacheable()
@@ -117,8 +115,7 @@ public void FetchIsCacheable()
117115
Sfi.Statistics.Clear();
118116
Sfi.EvictQueries();
119117

120-
Order order;
121-
order = db.Orders
118+
var order = db.Orders
122119
.Fetch(
123120
SelectMode.Fetch,
124121
x => x.Customer,
@@ -159,20 +156,18 @@ public void FetchIsCacheable()
159156
Assert.That(Sfi.Statistics.QueryCacheHitCount, Is.EqualTo(1), "Unexpected cache hit count");
160157
}
161158

162-
163159
[Test]
164160
public void FetchIsCacheableForJoinAlias()
165161
{
166162
Sfi.Statistics.Clear();
167163
Sfi.EvictQueries();
168164

169-
Order order;
170165
Customer customer = null;
171166
OrderLine orderLines = null;
172167
Product product = null;
173168
OrderLine prOrderLines = null;
174-
175-
order = db.Orders
169+
170+
var order = db.Orders
176171
.JoinAlias(x => x.Customer, () => customer)
177172
.JoinAlias(x => x.OrderLines, () => orderLines, JoinType.LeftOuterJoin)
178173
.JoinAlias(() => orderLines.Product, () => product)
@@ -216,15 +211,13 @@ public void FutureFetchIsCacheable()
216211
Sfi.EvictQueries();
217212
var multiQueries = Sfi.ConnectionProvider.Driver.SupportsMultipleQueries;
218213

219-
Order order;
220-
221214
db.Orders
222215
.Fetch(SelectMode.Fetch, x => x.Customer)
223216
.Where(x => x.OrderId == 10248)
224217
.Cacheable()
225218
.Future();
226219

227-
order = db.Orders
220+
var order = db.Orders
228221
.Fetch(
229222
SelectMode.Fetch,
230223
x => x.OrderLines,
@@ -273,12 +266,12 @@ public void FutureFetchIsCacheable()
273266

274267
private static void AssertFetchedOrder(Order order)
275268
{
276-
Assert.That(order.Customer, Is.Not.Null, "Expected the fetched Customer to be initialized");
269+
Assert.That(order.Customer, Is.Not.Null, "Expected the fetched Customer to be not null");
277270
Assert.That(NHibernateUtil.IsInitialized(order.Customer), Is.True, "Expected the fetched Customer to be initialized");
278271
Assert.That(NHibernateUtil.IsInitialized(order.OrderLines), Is.True, "Expected the fetched OrderLines to be initialized");
279272
Assert.That(order.OrderLines, Has.Count.EqualTo(3), "Expected the fetched OrderLines to have 3 items");
280273
var orderLine = order.OrderLines.First();
281-
Assert.That(orderLine.Product, Is.Not.Null, "Expected the fetched Product to be initialized");
274+
Assert.That(orderLine.Product, Is.Not.Null, "Expected the fetched Product to be not null");
282275
Assert.That(NHibernateUtil.IsInitialized(orderLine.Product), Is.True, "Expected the fetched Product to be initialized");
283276
Assert.That(NHibernateUtil.IsInitialized(orderLine.Product.OrderLines), Is.True, "Expected the fetched OrderLines to be initialized");
284277
}

‎src/NHibernate.Test/Criteria/ReadonlyTests/_ReadonlyFixtureSetUp.cs‎ renamed to ‎src/NHibernate.Test/Criteria/ReadonlyTests/ReadonlyFixtureSetUp.cs‎

File renamed without changes.

0 commit comments

Comments
 (0)