public static async Task WriteCacheOnUpdateAsync(TokenCacheUpdatedArgs args)
{
using (var cacheStream = new FileStream(TOKEN_CACHE_PATH, FileMode.Create, FileAccess.Write))
{
await TokenCacheSerializer.SerializeAsync(args.Cache, cacheStream);
}
}
public async Task Identity_TokenCache_CustomPersistence_Write()
{
var tokenCache = new TokenCache();
#region Snippet:Identity_TokenCache_CustomPersistence_Write
using (var cacheStream = new FileStream(TOKEN_CACHE_PATH, FileMode.Create, FileAccess.Write))
{
await TokenCacheSerializer.SerializeAsync(tokenCache, cacheStream);
}
#endregion
}
public async Task Identity_TokenCache_CustomPersistence_Read()
{
#region Snippet:Identity_TokenCache_CustomPersistence_Read
TokenCache tokenCache;
using (var cacheStream = new FileStream(TOKEN_CACHE_PATH, FileMode.OpenOrCreate, FileAccess.Read))
{
tokenCache = await TokenCacheSerializer.DeserializeAsync(cacheStream);
}
#endregion
}
public static async Task <TokenCache> ReadTokenCacheAsync()
{
TokenCache tokenCache;
using (var cacheStream = new FileStream(TOKEN_CACHE_PATH, FileMode.OpenOrCreate, FileAccess.Read))
{
tokenCache = await TokenCacheSerializer.DeserializeAsync(cacheStream);
tokenCache.Updated += WriteCacheOnUpdateAsync;
}
return(tokenCache);
}
public async Task DeSerialize(bool async)
{
byte[] buff = new byte[TestBufferSize];
rand.NextBytes(buff);
var stream = new MemoryStream(buff);
var expectedCache = new TokenCache(buff);
TokenCache actualCache;
if (async)
{
actualCache = await TokenCacheSerializer.DeserializeAsync(stream);
}
else
{
actualCache = TokenCacheSerializer.Deserialize(stream);
}
Assert.That(actualCache.Data, Is.EquivalentTo(buff));
}
public async Task Serialize(bool async)
{
byte[] buff = new byte[TestBufferSize];
rand.NextBytes(buff);
var expectedStream = new MemoryStream(buff);
var actualStream = new MemoryStream();
var cache = new TokenCache(buff);
if (async)
{
await TokenCacheSerializer.SerializeAsync(cache, actualStream);
}
else
{
TokenCacheSerializer.Serialize(cache, actualStream);
}
expectedStream.Position = 0;
actualStream.Position = 0;
Assert.That(expectedStream.Length, Is.EqualTo(actualStream.Length));
Assert.That(expectedStream.ToArray(), Is.EquivalentTo(actualStream.ToArray()));
}
public void DeserializeInputChecks()
{
Assert.Throws <ArgumentNullException>(() => TokenCacheSerializer.Deserialize(null));
Assert.ThrowsAsync <ArgumentNullException>(async() => await TokenCacheSerializer.DeserializeAsync(null));
}
public void SerializeInputChecks(TokenCache cache, Stream stream)
{
Assert.Throws <ArgumentNullException>(() => TokenCacheSerializer.Serialize(cache, stream));
Assert.ThrowsAsync <ArgumentNullException>(async() => await TokenCacheSerializer.SerializeAsync(cache, stream));
}
