public void TestSizesCompress()
{
var code = new SimpleAuthorizationCode
{
Client = new SimpleClient
{
ClientId = "cid"
},
RequestedScopes = new List<SimpleScope> { new SimpleScope { Description = "this is description", Enabled = true, Name = "Scope", DisplayName = "Display Name" } },
Subject = new SimpleClaimsPrincipal
{
Identities = new List<SimpleClaimsIdentity> { new SimpleClaimsIdentity { Claims = new List<SimpleClaim>() } }
},
CodeChallenge = "CodeChallenge",
CodeChallengeMethod = "CodeChallengeMethod",
CreationTime = new DateTimeOffset(new DateTime(2016, 1, 1)),
IsOpenId = true,
Nonce = "Nonce",
RedirectUri = "RedirectUri",
SessionId = "SessionId",
WasConsentShown = true
};
var jsonSettingsFactory = new JsonSettingsFactory(new CustomMappersConfiguration()).Create();
var serializeObject = JsonConvert.SerializeObject(code, jsonSettingsFactory);
Console.WriteLine($"{Encoding.UTF8.GetByteCount(serializeObject.Compress())} bytes");
}
public void GetAsync_WhenCalled_ExpectResponse()
{
// Arrange
var mockCacheConfiguration = new Mock<IConfiguration<RedisCacheConfigurationEntity>>();
mockCacheConfiguration.Setup(r => r.Get).Returns(
new RedisCacheConfigurationEntity
{
CacheDuration = 10,
RedisCacheDefaultPrefix = "DEFAULT",
UseObjectCompression = false
});
var jsonSettingsFactory = new JsonSettingsFactory(new CustomMappersConfiguration());
var cacheManager = new RedisCacheManager<Token>(
RedisHelpers.ConnectionMultiplexer,
mockCacheConfiguration.Object,
jsonSettingsFactory.Create());
var tokenStore = new TokenHandleStore(
cacheManager,
mockCacheConfiguration.Object);
// Act
var stopwatch = Stopwatch.StartNew();
var token = tokenStore.GetAsync("Existing").Result;
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(token, Is.Not.Null);
}
public void GetAsync_WhenCalled_ExpectResponse()
{
// Arrange
var mockCacheConfiguration = new Mock<IConfiguration<RedisCacheConfigurationEntity>>();
mockCacheConfiguration.Setup(r => r.Get).Returns(
new RedisCacheConfigurationEntity
{
CacheDuration = 10,
RedisCacheDefaultPrefix = "DEFAULT",
UseObjectCompression = false
});
var jsonSettingsFactory = new JsonSettingsFactory(new CustomMappersConfiguration());
var cacheManager = new RedisCacheManager<AuthorizationCode>(
RedisHelpers.ConnectionMultiplexer,
mockCacheConfiguration.Object,
jsonSettingsFactory.Create());
var authorizationCodeStore = new AuthorizationCodeStore(
cacheManager,
mockCacheConfiguration.Object);
// Act
var stopwatch = Stopwatch.StartNew();
var authorizationCode = authorizationCodeStore.GetAsync("Existing").Result;
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(authorizationCode, Is.Not.Null);
Assert.That(authorizationCode.Client, Is.Not.Null);
Assert.That(authorizationCode.ClientId, Is.EqualTo("cid"));
Assert.That(authorizationCode.CodeChallenge, Is.EqualTo("CodeChallenge"));
Assert.That(authorizationCode.CodeChallengeMethod, Is.EqualTo("CodeChallengeMethod"));
Assert.That(authorizationCode.CreationTime, Is.EqualTo(new DateTimeOffset(new DateTime(2016, 1, 1))));
Assert.That(authorizationCode.IsOpenId, Is.True);
Assert.That(authorizationCode.Nonce, Is.EqualTo("Nonce"));
Assert.That(authorizationCode.RedirectUri, Is.EqualTo("RedirectUri"));
Assert.That(authorizationCode.RequestedScopes, Is.Not.Null);
Assert.That(authorizationCode.RequestedScopes.Count(), Is.EqualTo(1));
Assert.That(authorizationCode.Scopes, Is.Not.Null);
Assert.That(authorizationCode.Scopes.Count(), Is.EqualTo(1));
Assert.That(authorizationCode.SessionId, Is.EqualTo("SessionId"));
Assert.That(authorizationCode.WasConsentShown, Is.True);
Assert.That(authorizationCode.Subject, Is.Not.Null);
}
public void RemoveAsync_WhenCalled_ExpectAction()
{
// Arrange
var mockCacheConfiguration = new Mock<IConfiguration<RedisCacheConfigurationEntity>>();
mockCacheConfiguration.Setup(r => r.Get).Returns(
new RedisCacheConfigurationEntity
{
CacheDuration = 10,
RedisCacheDefaultPrefix = "DEFAULT",
UseObjectCompression = false
});
var jsonSettingsFactory = new JsonSettingsFactory(new CustomMappersConfiguration());
var cacheManager = new RedisCacheManager<RefreshToken>(
RedisHelpers.ConnectionMultiplexer,
mockCacheConfiguration.Object,
jsonSettingsFactory.Create());
var refreshTokenStore = new RefreshTokenStore(
cacheManager,
mockCacheConfiguration.Object);
// Act
var stopwatch = Stopwatch.StartNew();
refreshTokenStore.RemoveAsync("Delete").Wait();
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
var redisValue = RedisHelpers.ConnectionMultiplexer.GetDatabase().StringGet("DEFAULT_RTS_Delete");
Assert.That(redisValue.HasValue, Is.False);
}
public void TestFixtureSetup()
{
var database = RedisHelpers.ConnectionMultiplexer.GetDatabase();
var refreshToken = new RefreshToken
{
AccessToken = new Token
{
Client = new Client { ClientId = "cid", },
Claims = new List<Claim> { new Claim("SubjectId", "sid") }
},
CreationTime = new DateTimeOffset(new DateTime(2016, 1, 1)),
LifeTime = 1600,
Version = 1,
Subject = new ClaimsPrincipal()
};
var settings = new JsonSettingsFactory(new CustomMappersConfiguration()).Create();
var serialized = JsonConvert.SerializeObject(refreshToken, settings);
database.StringSet("DEFAULT_RTS_Existing", serialized);
database.StringSet("DEFAULT_RTS_Delete", serialized);
}
public void StoreAsync_WhenCalled_ExpectAction()
{
// Arrange
var mockCacheConfiguration = new Mock<IConfiguration<RedisCacheConfigurationEntity>>();
mockCacheConfiguration.Setup(r => r.Get).Returns(
new RedisCacheConfigurationEntity
{
CacheDuration = 10,
RedisCacheDefaultPrefix = "DEFAULT",
UseObjectCompression = false
});
var jsonSettingsFactory = new JsonSettingsFactory(new CustomMappersConfiguration());
var cacheManager = new RedisCacheManager<RefreshToken>(
RedisHelpers.ConnectionMultiplexer,
mockCacheConfiguration.Object,
jsonSettingsFactory.Create());
var refreshTokenStore = new RefreshTokenStore(
cacheManager,
mockCacheConfiguration.Object);
var refreshToken = new RefreshToken
{
AccessToken = new Token
{
Client = new Client { ClientId = "cid", },
Claims = new List<Claim> { new Claim("SubjectId", "sid") }
},
CreationTime = new DateTimeOffset(new DateTime(2016, 1, 1)),
LifeTime = 1600,
Version = 1,
};
// Act
var stopwatch = Stopwatch.StartNew();
refreshTokenStore.StoreAsync("KeyToStore", refreshToken).Wait();
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
var redisValue = RedisHelpers.ConnectionMultiplexer.GetDatabase().StringGet("DEFAULT_RTS_KeyToStore");
Assert.That(redisValue.HasValue, Is.True);
Console.WriteLine(redisValue);
}
public void TestFixtureSetup()
{
var database = RedisHelpers.ConnectionMultiplexer.GetDatabase();
var subject =
new ClaimsPrincipal(
new List<ClaimsIdentity>
{
new ClaimsIdentity(
new List<Claim>
{
new Claim(Constants.ClaimTypes.Subject, "sid")
})
});
var code = new AuthorizationCode
{
Client = new Client
{
ClientId = "cid"
},
RequestedScopes =
new List<Scope>
{
new Scope
{
Description = "this is description",
Enabled = true,
Name = "Scope",
DisplayName = "Display Name"
}
},
Subject = subject,
CodeChallenge = "CodeChallenge",
CodeChallengeMethod = "CodeChallengeMethod",
CreationTime = new DateTimeOffset(new DateTime(2016, 1, 1)),
IsOpenId = true,
Nonce = "Nonce",
RedirectUri = "RedirectUri",
SessionId = "SessionId",
WasConsentShown = true
};
var settings = new JsonSettingsFactory(new CustomMappersConfiguration()).Create();
var serialized = JsonConvert.SerializeObject(code, settings);
database.StringSet("DEFAULT_ACS_Existing", serialized);
database.StringSet("DEFAULT_ACS_Delete", serialized);
}
public void StoreAsync_WhenCalled_ExpectAction()
{
// Arrange
var mockCacheConfiguration = new Mock<IConfiguration<RedisCacheConfigurationEntity>>();
mockCacheConfiguration.Setup(r => r.Get).Returns(
new RedisCacheConfigurationEntity
{
CacheDuration = 10,
RedisCacheDefaultPrefix = "DEFAULT",
UseObjectCompression = false
});
var jsonSettingsFactory = new JsonSettingsFactory(new CustomMappersConfiguration());
var cacheManager = new RedisCacheManager<AuthorizationCode>(
RedisHelpers.ConnectionMultiplexer,
mockCacheConfiguration.Object,
jsonSettingsFactory.Create());
var authorizationCodeStore = new AuthorizationCodeStore(
cacheManager,
mockCacheConfiguration.Object);
var subject =
new ClaimsPrincipal(
new List<ClaimsIdentity>
{
new ClaimsIdentity(
new List<Claim>
{
new Claim(Constants.ClaimTypes.Subject, "sid")
})
});
var code = new AuthorizationCode
{
Client = new Client
{
ClientId = "cid"
},
RequestedScopes = new List<Scope> { new Scope { Description = "this is description", Enabled = true, Name = "Scope", DisplayName = "Display Name" } },
Subject = subject
};
// Act
var stopwatch = Stopwatch.StartNew();
authorizationCodeStore.StoreAsync("KeyToStore", code).Wait();
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
var redisValue = RedisHelpers.ConnectionMultiplexer.GetDatabase().StringGet("DEFAULT_ACS_KeyToStore");
Assert.That(redisValue.HasValue, Is.True);
Console.WriteLine(redisValue);
}
public void SetAsync_WhenClaimObject_ExpectSuccess()
{
// arrange
const string Key = @"SetAsync_WhenClaimObject_ExpectSuccess";
var claim = new Claim("mytype1", "myvalue2");
var claims = new List<Claim> { claim, claim, claim };
var timeSpan = TimeSpan.FromSeconds(10);
var mockConfiguration = new Mock<IConfiguration<RedisCacheConfigurationEntity>>();
mockConfiguration.Setup(r => r.Get)
.Returns(
() =>
new RedisCacheConfigurationEntity
{
CacheDuration = 3600,
UseObjectCompression = true,
RedisCacheDefaultPrefix = @"RedisCacheManagerTests"
});
var jsonSettingsFactory = new JsonSettingsFactory(new CustomMappersConfiguration());
// act
var redisCacheManager = new RedisCacheManager<IEnumerable<Claim>>(
RedisHelpers.ConnectionMultiplexer,
mockConfiguration.Object,
jsonSettingsFactory.Create());
redisCacheManager.SetAsync(Key, claims, timeSpan).Wait();
var result = redisCacheManager.GetAsync(Key).Result.ToList();
// assert
Console.WriteLine(@"Fetched From Cache:{0}", JsonConvert.SerializeObject(result));
Assert.That(result.GetType(), Is.EqualTo(typeof(List<Claim>)));
}
public void TestFixtureSetup()
{
var database = RedisHelpers.ConnectionMultiplexer.GetDatabase();
var claim1 = new SimpleClaim { Type = "Type1", Value = "Value1" };
var claim2 = new SimpleClaim { Type = "Type2", Value = "Value2" };
var client = new SimpleClient
{
Claims = new List<SimpleClaim> { claim1, claim2 },
DataBag = new Dictionary<string, object> { { "AppId", 12 } }
};
var token = new SimpleToken
{
Claims = new List<SimpleClaim> { claim1, claim2 },
Client = client,
Type = "Type",
CreationTime = new DateTimeOffset(new DateTime(2016, 1, 1)),
Version = 1,
Issuer = "Issuer",
Lifetime = 120,
Audience = "Audience"
};
var settings = new JsonSettingsFactory(new CustomMappersConfiguration { ClientMapper = CustomMapperFactory.CreateClientMapper<CustomClient>() }).Create();
var serialized = JsonConvert.SerializeObject(token, settings);
database.StringSet("DEFAULT_THS_Existing", serialized);
database.StringSet("DEFAULT_THS_Delete", serialized);
}
public void StoreAsync_WhenCalled_ExpectAction()
{
// Arrange
var mockCacheConfiguration = new Mock<IConfiguration<RedisCacheConfigurationEntity>>();
mockCacheConfiguration.Setup(r => r.Get).Returns(
new RedisCacheConfigurationEntity
{
CacheDuration = 10,
RedisCacheDefaultPrefix = "DEFAULT",
UseObjectCompression = false
});
var customMappersConfiguration = new CustomMappersConfiguration
{
ClientMapper = CustomMapperFactory.CreateClientMapper<CustomClient>()
};
var jsonSettingsFactory = new JsonSettingsFactory(customMappersConfiguration);
var cacheManager = new RedisCacheManager<Token>(
RedisHelpers.ConnectionMultiplexer,
mockCacheConfiguration.Object,
jsonSettingsFactory.Create());
var tokenStore = new TokenHandleStore(
cacheManager,
mockCacheConfiguration.Object);
var claim1 = new Claim("Type1", "Value1");
var claim2 = new Claim("Type2", "Value2");
var client = new CustomClient
{
Claims = new List<Claim> { claim1, claim2 }
};
var token = new Token
{
Claims = new List<Claim> { claim1, claim2 },
Client = client,
Type = "Type",
CreationTime = new DateTimeOffset(new DateTime(2016, 1, 1)),
Version = 1,
Issuer = "Issuer",
Lifetime = 120,
Audience = "Audience"
};
// Act
var stopwatch = Stopwatch.StartNew();
tokenStore.StoreAsync("KeyToStore", token).Wait();
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
var redisValue = RedisHelpers.ConnectionMultiplexer.GetDatabase().StringGet("DEFAULT_THS_KeyToStore");
Assert.That(redisValue.HasValue, Is.True);
Console.WriteLine(redisValue);
}
/// <summary>
/// Initializes this instance.
/// </summary>
/// <returns>The <see cref="Caches"/></returns>
private static Entities.Caches Initialize()
{
var jsonSettingsFactory = new JsonSettingsFactory(incomingMappers);
var settings = jsonSettingsFactory.Create();
var authorizationCacheManager = new RedisCacheManager<AuthorizationCode>(
ConnectionMultiplexer,
Configuration,
settings);
var authorizationCodeStore = new AuthorizationCodeStore(
authorizationCacheManager,
Configuration);
var clientCacheManager = new RedisCacheManager<Client>(
ConnectionMultiplexer,
Configuration,
settings);
var clientCache = new ClientStoreCache(
clientCacheManager,
Configuration);
var refreshTokenCacheManager = new RedisCacheManager<RefreshToken>(
ConnectionMultiplexer,
Configuration,
settings);
var refreshTokenStore = new RefreshTokenStore(
refreshTokenCacheManager,
Configuration);
var scopeCacheManager = new RedisCacheManager<IEnumerable<Scope>>(
ConnectionMultiplexer,
Configuration,
settings);
var scopesCache = new ScopeStoreCache(
scopeCacheManager,
Configuration);
var redisHandleCacheManager = new RedisCacheManager<Token>(
ConnectionMultiplexer,
Configuration,
settings);
var tokenHandleStore = new TokenHandleStore(
redisHandleCacheManager,
Configuration);
var userServiceCacheManager = new RedisCacheManager<IEnumerable<Claim>>(
ConnectionMultiplexer,
Configuration,
settings);
var userServiceCache = new UserServiceCache(
userServiceCacheManager,
Configuration);
var caches = new Entities.Caches
{
AuthorizationCodeStore = authorizationCodeStore,
ClientCache = clientCache,
RefreshTokenStore = refreshTokenStore,
ScopesCache = scopesCache,
TokenHandleStore = tokenHandleStore,
UserServiceCache = userServiceCache
};
return caches;
}
