Skip to content
This repository was archived by the owner on Nov 22, 2018. It is now read-only.

Commit a2a6b99

Browse files
JunTaoLuoJunTaoLuo
committed
Add tests
1 parent d473bbe commit a2a6b99

File tree

2 files changed

+153
-53
lines changed

2 files changed

+153
-53
lines changed

‎src/Microsoft.AspNetCore.Session/LoggingExtensions.cs‎

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -42,16 +42,15 @@ static LoggingExtensions()
4242
_sessionCacheReadException = LoggerMessage.Define<string>(
4343
eventId: 6,
4444
logLevel: LogLevel.Error,
45-
formatString: "Session read exception, Key:{sessionKey}");
45+
formatString: "Session cache read exception, Key:{sessionKey}");
4646
_sessionCacheWriteException = LoggerMessage.Define<string, string>(
4747
eventId: 7,
4848
logLevel: LogLevel.Error,
49-
formatString: "Session write exception, Key:{sessionKey}, Id:{sessionId}");
49+
formatString: "Session cache write exception, Key:{sessionKey}, Id:{sessionId}");
5050
_sessionCacheRefreshException = LoggerMessage.Define<string>(
5151
eventId: 8,
5252
logLevel: LogLevel.Error,
53-
formatString: "Session refresh exception, Key:{sessionKey}");
54-
formatString: "Session refresh exception, Key:{sessionKey}, Exception:{exception}");
53+
formatString: "Session cache refresh exception, Key:{sessionKey}");
5554
_errorUnprotectingCookie = LoggerMessage.Define(
5655
eventId: 9,
5756
logLevel: LogLevel.Warning,

‎test/Microsoft.AspNetCore.Session.Tests/SessionTests.cs‎

Lines changed: 150 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -40,7 +40,6 @@ public async Task ReadingEmptySessionDoesNotCreateCookie()
4040
})
4141
.ConfigureServices(services =>
4242
{
43-
services.AddMemoryCache();
4443
services.AddDistributedMemoryCache();
4544
services.AddSession();
4645
});
@@ -72,7 +71,6 @@ public async Task SettingAValueCausesTheCookieToBeCreated()
7271
})
7372
.ConfigureServices(services =>
7473
{
75-
services.AddMemoryCache();
7674
services.AddDistributedMemoryCache();
7775
services.AddSession();
7876
});
@@ -111,9 +109,7 @@ public async Task SessionCanBeAccessedOnTheNextRequest()
111109
})
112110
.ConfigureServices(services =>
113111
{
114-
services.AddMemoryCache();
115112
services.AddDistributedMemoryCache();
116-
117113
services.AddSession();
118114
});
119115

@@ -166,9 +162,7 @@ public async Task RemovedItemCannotBeAccessedAgain()
166162
.ConfigureServices(
167163
services =>
168164
{
169-
services.AddMemoryCache();
170165
services.AddDistributedMemoryCache();
171-
172166
services.AddSession();
173167
});
174168

@@ -219,9 +213,7 @@ public async Task ClearedItemsCannotBeAccessedAgain()
219213
})
220214
.ConfigureServices(services =>
221215
{
222-
services.AddMemoryCache();
223216
services.AddDistributedMemoryCache();
224-
225217
services.AddSession();
226218
});
227219

@@ -258,10 +250,7 @@ public async Task SessionStart_LogsInformation()
258250
.ConfigureServices(services =>
259251
{
260252
services.AddSingleton(typeof(ILoggerFactory), loggerFactory);
261-
262-
services.AddMemoryCache();
263253
services.AddDistributedMemoryCache();
264-
265254
services.AddSession();
266255
});
267256

@@ -310,10 +299,7 @@ public async Task ExpiredSession_LogsWarning()
310299
.ConfigureServices(services =>
311300
{
312301
services.AddSingleton(typeof(ILoggerFactory), loggerFactory);
313-
314-
services.AddMemoryCache();
315302
services.AddDistributedMemoryCache();
316-
317303
services.AddSession(o => o.IdleTimeout = TimeSpan.FromMilliseconds(30));
318304
});
319305

@@ -373,10 +359,7 @@ public async Task RefreshesSession_WhenSessionData_IsNotModified()
373359
.ConfigureServices(services =>
374360
{
375361
services.AddSingleton(typeof(ILoggerFactory), new NullLoggerFactory());
376-
377-
services.AddMemoryCache();
378362
services.AddDistributedMemoryCache();
379-
380363
services.AddSession(o => o.IdleTimeout = TimeSpan.FromMinutes(20));
381364
services.Configure<MemoryCacheOptions>(o => o.Clock = clock);
382365
});
@@ -426,9 +409,7 @@ public async Task SessionFeature_IsUnregistered_WhenResponseGoingOut()
426409
})
427410
.ConfigureServices(services =>
428411
{
429-
services.AddMemoryCache();
430412
services.AddDistributedMemoryCache();
431-
432413
services.AddSession();
433414
});
434415

@@ -471,9 +452,7 @@ public async Task SessionFeature_IsUnregistered_WhenResponseGoingOut_AndAnUnhand
471452
})
472453
.ConfigureServices(services =>
473454
{
474-
services.AddMemoryCache();
475455
services.AddDistributedMemoryCache();
476-
477456
services.AddSession();
478457
});
479458

@@ -502,9 +481,7 @@ public async Task SessionKeys_AreCaseSensitive()
502481
})
503482
.ConfigureServices(services =>
504483
{
505-
services.AddMemoryCache();
506484
services.AddDistributedMemoryCache();
507-
508485
services.AddSession();
509486
});
510487

@@ -516,61 +493,185 @@ public async Task SessionKeys_AreCaseSensitive()
516493
}
517494
}
518495

519-
private class TestClock : ISystemClock
496+
[Fact]
497+
public async Task SessionLogsCacheReadException()
520498
{
521-
public TestClock()
499+
var sink = new TestSink();
500+
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
501+
var builder = new WebHostBuilder()
502+
.Configure(app =>
503+
{
504+
app.UseSession();
505+
app.Run(context =>
506+
{
507+
byte[] value;
508+
Assert.False(context.Session.TryGetValue("key", out value));
509+
Assert.Equal(default(byte[]), value);
510+
Assert.Equal(default(string), context.Session.Id);
511+
Assert.Equal(default(IEnumerable<string>), context.Session.Keys);
512+
return Task.FromResult(0);
513+
});
514+
})
515+
.ConfigureServices(services =>
516+
{
517+
services.AddSingleton(typeof(ILoggerFactory), loggerFactory);
518+
services.AddSingleton<IDistributedCache>(new UnreliableCache(new MemoryCache(new MemoryCacheOptions()))
519+
{
520+
DisableGet = true
521+
});
522+
services.AddSession();
523+
});
524+
525+
using (var server = new TestServer(builder))
522526
{
523-
UtcNow = new DateTimeOffset(2013, 1, 1, 1, 0, 0, TimeSpan.Zero);
524-
}
527+
var client = server.CreateClient();
528+
var response = await client.GetAsync(string.Empty);
529+
response.EnsureSuccessStatusCode();
525530

526-
public DateTimeOffset UtcNow { get; private set; }
531+
var sessionLogMessages = sink.Writes.OnlyMessagesFromSource<DistributedSession>().ToArray();
527532

528-
public void Add(TimeSpan timespan)
529-
{
530-
UtcNow = UtcNow.Add(timespan);
533+
Assert.Equal(1, sessionLogMessages.Length);
534+
Assert.Contains("Session cache read exception", sessionLogMessages[0].State.ToString());
535+
Assert.Equal(LogLevel.Error, sessionLogMessages[0].LogLevel);
531536
}
532537
}
533538

534-
private class TestDistributedCache : IDistributedCache
539+
[Fact]
540+
public async Task SessionLogsCacheWriteException()
535541
{
536-
public byte[] Get(string key)
542+
var sink = new TestSink();
543+
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
544+
var builder = new WebHostBuilder()
545+
.Configure(app =>
546+
{
547+
app.UseSession();
548+
app.Run(context =>
549+
{
550+
context.Session.SetInt32("key", 0);
551+
return Task.FromResult(0);
552+
});
553+
})
554+
.ConfigureServices(services =>
555+
{
556+
services.AddSingleton(typeof(ILoggerFactory), loggerFactory);
557+
services.AddSingleton<IDistributedCache>(new UnreliableCache(new MemoryCache(new MemoryCacheOptions()))
558+
{
559+
DisableSetAsync = true
560+
});
561+
services.AddSession();
562+
});
563+
564+
using (var server = new TestServer(builder))
537565
{
538-
throw new NotImplementedException();
566+
var client = server.CreateClient();
567+
var response = await client.GetAsync(string.Empty);
568+
response.EnsureSuccessStatusCode();
569+
570+
var sessionLogMessages = sink.Writes.OnlyMessagesFromSource<DistributedSession>().ToArray();
571+
572+
Assert.Equal(2, sessionLogMessages.Length);
573+
Assert.Contains("Session started", sessionLogMessages[0].State.ToString());
574+
Assert.Equal(LogLevel.Information, sessionLogMessages[0].LogLevel);
575+
Assert.Contains("Session cache write exception", sessionLogMessages[1].State.ToString());
576+
Assert.Equal(LogLevel.Error, sessionLogMessages[1].LogLevel);
539577
}
578+
}
579+
580+
[Fact]
581+
public async Task SessionLogsCacheRefreshException()
582+
{
583+
var sink = new TestSink();
584+
var loggerFactory = new TestLoggerFactory(sink, enabled: true);
585+
var builder = new WebHostBuilder()
586+
.Configure(app =>
587+
{
588+
app.UseSession();
589+
app.Run(context =>
590+
{
591+
// The middleware calls context.Session.CommitAsync() once per request
592+
return Task.FromResult(0);
593+
});
594+
})
595+
.ConfigureServices(services =>
596+
{
597+
services.AddSingleton(typeof(ILoggerFactory), loggerFactory);
598+
services.AddSingleton<IDistributedCache>(new UnreliableCache(new MemoryCache(new MemoryCacheOptions()))
599+
{
600+
DisableRefreshAsync = true
601+
});
602+
services.AddSession();
603+
});
540604

541-
public Task<byte[]> GetAsync(string key)
605+
using (var server = new TestServer(builder))
542606
{
543-
throw new NotImplementedException();
607+
var client = server.CreateClient();
608+
var response = await client.GetAsync(string.Empty);
609+
response.EnsureSuccessStatusCode();
610+
611+
var sessionLogMessages = sink.Writes.OnlyMessagesFromSource<DistributedSession>().ToArray();
612+
613+
Assert.Equal(1, sessionLogMessages.Length);
614+
Assert.Contains("Session cache refresh exception", sessionLogMessages[0].State.ToString());
615+
Assert.Equal(LogLevel.Error, sessionLogMessages[0].LogLevel);
544616
}
617+
}
545618

546-
public void Refresh(string key)
619+
private class TestClock : ISystemClock
620+
{
621+
public TestClock()
547622
{
548-
throw new NotImplementedException();
623+
UtcNow = new DateTimeOffset(2013, 1, 1, 1, 0, 0, TimeSpan.Zero);
549624
}
550625

551-
public Task RefreshAsync(string key)
626+
public DateTimeOffset UtcNow { get; private set; }
627+
628+
public void Add(TimeSpan timespan)
552629
{
553-
throw new NotImplementedException();
630+
UtcNow = UtcNow.Add(timespan);
554631
}
632+
}
633+
634+
private class UnreliableCache : IDistributedCache
635+
{
636+
private readonly MemoryDistributedCache _cache;
637+
638+
public bool DisableGet { get; set; }
639+
public bool DisableSetAsync { get; set; }
640+
public bool DisableRefreshAsync { get; set; }
555641

556-
public void Remove(string key)
642+
public UnreliableCache(IMemoryCache memoryCache)
557643
{
558-
throw new NotImplementedException();
644+
_cache = new MemoryDistributedCache(memoryCache);
559645
}
560646

561-
public Task RemoveAsync(string key)
647+
public byte[] Get(string key)
562648
{
563-
throw new NotImplementedException();
649+
if (DisableGet)
650+
{
651+
throw new InvalidOperationException();
652+
}
653+
return _cache.Get(key);
564654
}
565-
566-
public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
655+
public Task<byte[]> GetAsync(string key) => _cache.GetAsync(key);
656+
public void Refresh(string key) => _cache.Refresh(key);
657+
public Task RefreshAsync(string key)
567658
{
568-
throw new NotImplementedException();
659+
if (DisableRefreshAsync)
660+
{
661+
throw new InvalidOperationException();
662+
}
663+
return _cache.RefreshAsync(key);
569664
}
570-
665+
public void Remove(string key) => _cache.Remove(key);
666+
public Task RemoveAsync(string key) => _cache.RemoveAsync(key);
667+
public void Set(string key, byte[] value, DistributedCacheEntryOptions options) => _cache.Set(key, value, options);
571668
public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options)
572669
{
573-
throw new NotImplementedException();
670+
if (DisableSetAsync)
671+
{
672+
throw new InvalidOperationException();
673+
}
674+
return _cache.SetAsync(key, value, options);
574675
}
575676
}
576677
}

0 commit comments

Comments
 (0)