protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
var connectionMultiplexer = StackExchange.Redis.ConnectionMultiplexer.Connect("localhost:6379,allowAdmin=true");
//connectionMultiplexer.GetServer("localhost", 6379).FlushAllDatabases();
var cc = connectionMultiplexer.GetServer("localhost", 6379);
RedisCacheProvider.SetConnectionMultiplexer(connectionMultiplexer);
//RedisCacheProvider.SetOptions(new RedisCacheProviderOptions()
//{
// Serializer = new NetDataContractCacheSerializer(),
// CacheConfigurations = new[]
// {
// new RedisCacheConfiguration("NHibernate.Cache.StandardQueryCache")
// {
// Expiration = TimeSpan.FromSeconds(9)
// }
// }
//});
var options = new RedisCacheProviderOptions();
options.Serializer = new NhJsonCacheSerializer();
options.KeyPrefix = "Sop:";
options.CacheConfigurations = new[]
{
new RedisCacheConfiguration("StandardQueryCache:")
{
Expiration = TimeSpan.FromSeconds(9),
RegionName = "RegionName:"
}
};
RedisCacheProvider.SetOptions(options);
var dbFile = HttpContext.Current.Server.MapPath("~/App_Data/sample.db");
if (File.Exists(dbFile))
{
File.Delete(dbFile);
}
var configuration = Fluently.Configure()
.Database(
SQLiteConfiguration.Standard.UsingFile(dbFile)
)
.Mappings(m => m.FluentMappings.Add(typeof(BlogPostMapping)))
.ExposeConfiguration(cfg => cfg.SetProperty(NHibernate.Cfg.Environment.GenerateStatistics, "true"))
.Cache(c => c.UseQueryCache().UseSecondLevelCache().ProviderClass <RedisCacheProvider>())
.BuildConfiguration();
new SchemaExport(configuration).Create(false, true);
SessionFactory = configuration.BuildSessionFactory();
}
static void Main(string[] args)
{
#region 初始化配置
RedisCacheProvider.SetRedisCluster(AppConfig.RedisServer()); //redis配置
#endregion
SWfsSubjectStatisticsService service = new SWfsSubjectStatisticsService();
string RunConfig = AppConfig.RunConfig();
Console.WriteLine("开始运行...");
if (RunConfig.Equals("0") || RunConfig.Equals("1"))
{
service.GetSubjectDataList(1); //今日新开
System.Threading.Thread.Sleep(3000);
Console.WriteLine("=====================================================");
}
if (RunConfig.Equals("0") || RunConfig.Equals("2"))
{
service.GetSubjectDataList(2); //进行中
System.Threading.Thread.Sleep(3000);
Console.WriteLine("=====================================================");
}
if (RunConfig.Equals("0") || RunConfig.Equals("3"))
{
service.GetSubjectDataList(3); //已结束
}
}
public ActionResult UpdateTestData(long index, string name, int age, string birthday)
{
RedisCacheProvider cacheProvider = new RedisCacheProvider();
//if (string.IsNullOrEmpty(name))
//{
// return Json(new { success = false, message = "請輸入姓名" }, JsonRequestBehavior.AllowGet);
//}
//if (!cache.Where(x => x.Name.ToLower() == name.ToLower()).Any())
//{
// return Json(new { success = false, message = "找不到資料" }, JsonRequestBehavior.AllowGet);
//}
//var data = cache.Where(x => x.Name.ToLower() == name.ToLower())
// .FirstOrDefault();
cacheProvider.ListUpdate(
index,
"VueTest:LoadData:VueTestModel",
new VueTestModel {
Name = name, Age = age, Birthday = birthday, Changed = false
});
return(Json(new { success = true, message = "更新完成" }, JsonRequestBehavior.AllowGet));
}
public void CleanupExpiredKeys_RemovesOldItems()
{
var redis = new RedisConnectionManager(_redisHost);
var client = newRedisClient(redis);
var provider = new RedisCacheProvider(redis);
client.Remove(new RedisExpiryManager(new CacheConfiguration(redis))._setKey);
var expiryManager = new RedisExpiryManager(new CacheConfiguration(redis));
var key1 = "my.expiringkey.1";
var key2 = "my.expiringkey.2";
var key3 = "my.expiringkey.3";
expiryManager.SetKeyExpiry(client, key1, new DateTime(2012, 1, 1, 12, 1, 1));
expiryManager.SetKeyExpiry(client, key2, new DateTime(2015, 1, 1, 12, 1, 2));
expiryManager.SetKeyExpiry(client, key3, new DateTime(2020, 1, 1, 12, 1, 3));
var result = expiryManager.GetExpiredKeys(client, new DateTime(2020, 1, 1, 12, 1, 5));
Assert.IsNotNull(result);
Assert.IsTrue(result.Contains(key1), "key 1 should exist");
Assert.IsTrue(result.Contains(key2), "key 2 should exist");
Assert.IsTrue(result.Contains(key3), "key 3 should exist");
Assert.AreEqual(3, result.Count());
expiryManager.RemoveKeyExpiry(client, result);
result = expiryManager.GetExpiredKeys(client, new DateTime(2020, 1, 1, 12, 1, 5));
Assert.AreEqual(0, result.Count());
}
private static void ApplyCachingProvider(CachingProviderType cachingProvider, RepositoryOptionsBuilder builder)
{
switch (cachingProvider)
{
case CachingProviderType.MicrosoftInMemory:
{
builder.UseCachingProvider(new InMemoryCacheProvider());
break;
}
case CachingProviderType.Redis:
{
var redis = new RedisCacheProvider(allowAdmin: true, defaultDatabase: 0, expiry: null);
redis.Server.FlushAllDatabases();
builder.UseCachingProvider(redis);
break;
}
default:
throw new ArgumentOutOfRangeException(nameof(cachingProvider));
}
}
public void RemoveByTag_ManyItemSingleTag_ReturnsNoValues()
{
var redis = new RedisConnectionManager();
var cache = new RedisCacheProvider(redis);
cache.Logger = new TestRedisLogger();
string key1 = "TagCacheTests:Add1";
string key2 = "TagCacheTests:Add2";
string key3 = "TagCacheTests:Add3";
String value1 = "Hello World!";
String value3 = "Two";
String value2 = "Three";
DateTime expires = new DateTime(2099, 12, 11);
var tags = new List <string> {
"another tag"
};
cache.Set(key1, value1, expires, tags);
cache.Set(key2, value2, expires, tags);
cache.Set(key3, value3, expires, tags);
var results = cache.GetByTag <String>(tags[0]);
Assert.IsNotNull(results);
Assert.AreEqual(results.Count, 3);
cache.RemoveByTag(tags[0]);
results = cache.GetByTag <String>(tags[0]);
Assert.IsNull(results);
}
static void Main(string[] args)
{
var config = new ConfigurationOptions();
config.Password = "******";
ICacheProvider cacheProvider =
new RedisCacheProvider("localhost:6379,password=zhaokun", new BinarySerializableService());
//ICacheProvider cacheProvider = new MemoryCacheProvider();
CacheManager.SetCacheProvider(() => cacheProvider);
CacheManager.GetGlobalCache().Set("test", "test");
CacheManager.GetCache <Program>().Set("test", "test");
CacheManager.GetCache <Program>().Set("test1", "test1");
CacheManager.GetCache <Program>().Set("test2", "test2");
CacheManager.GetCache <Program>().Set("test3", "test3");
CacheManager.GetCache(nameof(Program)).Set("test", "test");
System.Console.WriteLine(CacheManager.GetGlobalCache().Get <string>("test"));
System.Console.WriteLine(CacheManager.GetCache(nameof(Program)).Get <string>("test"));
TestMethod1();
TestMethod2();
TestMethod3();
TestMethod4();
TestMethod5();
System.Console.ReadKey();
}
public async Task ShouldReturnNullWhenMultipleKeysRemoved()
{
// Arrange
var cache = new RedisCacheProvider(_redis)
{
Logger = new TestRedisLogger()
};
var key1 = _fixture.FormatKey($"{Guid.NewGuid()}TagCacheTests:Add.First");
var key2 = _fixture.FormatKey($"{Guid.NewGuid()}TagCacheTests:Add.Second");
const string value1 = "Test Value 1";
const string value2 = "Test Value 2";
var expiry = DateTime.Now.AddSeconds(30);
await Task.WhenAll(cache.SetItem(key1, value1, expiry), cache.SetItem(key2, value2, expiry))
.ConfigureAwait(false);
var result1 = await cache.GetItem <string>(key1).ConfigureAwait(false);
var result2 = await cache.GetItem <string>(key2).ConfigureAwait(false);
result1.Value.ShouldBe(value1);
result2.Value.ShouldBe(value2);
// Act
await cache.Remove(key1, key2).ConfigureAwait(false);
result1 = await cache.GetItem <string>(key1).ConfigureAwait(false);
result2 = await cache.GetItem <string>(key2).ConfigureAwait(false);
// Assert
result1.ShouldBeNull();
result2.ShouldBeNull();
}
public async Task ShouldRemoveAllItemsByTag()
{
// Arrange
var cache = new RedisCacheProvider(_redis)
{
Logger = new TestRedisLogger()
};
var key1 = _fixture.FormatKey($"{Guid.NewGuid()}TagCacheTests:Add1");
var key2 = _fixture.FormatKey($"{Guid.NewGuid()}TagCacheTests:Add2");
var key3 = _fixture.FormatKey($"{Guid.NewGuid()}TagCacheTests:Add3");
const string value1 = "Test Value 1";
const string value2 = "Test Value 2";
const string value3 = "Test Value 3";
var tag = $"{Guid.NewGuid()}_tag";
var expiry = DateTime.Now.AddSeconds(30);
await Task.WhenAll(cache.SetItem(key1, value1, expiry, tag), cache.SetItem(key2, value2, expiry, tag),
cache.SetItem(key3, value3, expiry, tag)).ConfigureAwait(false);
// Act
var result = (await cache.GetByTag <string>(tag).ConfigureAwait(false)).ToArray();
result.ShouldNotBeNull();
result.ShouldNotBeEmpty();
await cache.RemoveByTag(tag).ConfigureAwait(false);
result = (await cache.GetByTag <string>(tag).ConfigureAwait(false)).ToArray();
// Assert
result.ShouldBeEmpty();
}
/// <summary>
///
/// </summary>
protected IntegrationTestBase()
{
RedisCacheProvider.InternalSetConnectionMultiplexer(ConnectionMultiplexer);
RedisCacheProvider.InternalSetOptions(CreateTestProviderOptions());
InitializeDatabasePaths();
using (var connection = new SqlConnection(masterConnectionString))
{
connection.Open();
//DeleteDatabaseIfExists(connection);
CreateDatabase(connection);
}
if (configuration == null)
{
//configuration = Fluently.Configure()
// .Database(
// MsSqlConfiguration.MsSql2008.ConnectionString(connectionString)
// )
// .Mappings(m => m.FluentMappings.Add(typeof(PersonMapping)))
// .ExposeConfiguration(cfg => cfg.SetProperty(NHibernate.Cfg.Environment.GenerateStatistics, "true"))
// .Cache(c => c.UseQueryCache().
// UseSecondLevelCache().
// ProviderClass<RedisCacheProvider>())
// .BuildConfiguration();
}
new SchemaExport(configuration).Create(false, true);
}
public async Task ShouldReturnObjectValueForValidKey()
{
// Arrange
var cache = new RedisCacheProvider(_redis)
{
Logger = new TestRedisLogger()
};
var key = _fixture.FormatKey($"{Guid.NewGuid()}TagCacheTests:Add");
var value = new TestObject
{
Property1 = "Foo",
Property2 = "Bar",
Property3 = 11
};
var expiry = DateTime.Now.AddSeconds(30);
await cache.SetItem(key, value, expiry).ConfigureAwait(false);
// Act
var result = await cache.GetItem <TestObject>(key).ConfigureAwait(false);
// Assert
result.ShouldNotBeNull();
result.Value.Property1.ShouldBe(value.Property1);
result.Value.Property2.ShouldBe(value.Property2);
result.Value.Property3.ShouldBe(value.Property3);
}
public void ItemExpires_RemovedFromCache()
{
var redis = new RedisConnectionManager();
// this is just testing the built in expiry
var config = new CacheConfiguration(redis);
var cache = new RedisCacheProvider(config);
cache.Logger = new TestRedisLogger();
string key = "TagCacheTests:ItemExpires_RemovedFromCache";
String value = "Hello World!";
DateTime expires = DateTime.Now.AddSeconds(3);
string tag1 = "tag1";
string tag2 = "tag2";
cache.Set(key, value, expires, new List<string> { tag1, tag2 });
var result = cache.Get<String>(key);
Assert.IsNotNull(result);
Assert.AreEqual(value, result);
Thread.Sleep(1000);
result = cache.Get<String>(key);
Assert.IsNotNull(result);
Assert.AreEqual(value, result);
Thread.Sleep(2500);
result = cache.Get<String>(key);
Assert.IsNull(result);
}
public void OverwriteWithAbsoluteExpirationTest()
{
var key = "OverwriteWithAbsoluteExpirationTest";
var val = Guid.NewGuid();
IHttpRuntimeCacheProvider cacheProvider = new RedisCacheProvider();
var result = cacheProvider.GetOrCreate <Guid>(key, () => val);
Assert.AreEqual(result, val);
var exist = cacheProvider.TryGet <Guid>(key, out val);
Assert.IsTrue(exist);
var val2 = Guid.NewGuid();
cacheProvider.Overwrite <Guid>(key, val2, DateTime.UtcNow.AddSeconds(4D));
Thread.Sleep(TimeSpan.FromSeconds(8D));
Guid val3;
exist = cacheProvider.TryGet <Guid>(key, out val3);
Assert.IsFalse(exist);
Assert.AreEqual(val3, Guid.Empty);
}
public RedisCacheIntegrationTests()
{
fakeClientManager = new StoppableRedisClientManager(this.ClientManager);
RedisCacheProvider.InternalSetClientManager(fakeClientManager);
if (File.Exists("tests.db"))
{
File.Delete("tests.db");
}
if (configuration == null)
{
configuration = Fluently.Configure()
.Database(
SQLiteConfiguration.Standard.UsingFile("tests.db")
)
.Mappings(m =>
{
m.FluentMappings.Add(typeof(PersonMapping));
})
.ExposeConfiguration(cfg =>
{
cfg.SetProperty(NHibernate.Cfg.Environment.GenerateStatistics, "true");
})
.Cache(c =>
{
c.UseQueryCache().UseSecondLevelCache().ProviderClass <RedisCacheProvider>();
})
.BuildConfiguration();
}
new SchemaExport(configuration).Create(false, true);
}
public void Ctor_Configuration__Succeeds()
{
var redis = new RedisConnectionManager("localhost");
var config = NewCacheConfiguration(redis);
config.RootNameSpace = "_TestRootNamespace";
config.Serializer = new BinarySerializationProvider();
config.RedisClientConfiguration = new RedisClientConfiguration(config.RedisClientConfiguration.RedisConnectionManagerConnectionManager)
{
Host = _redisHost,
DbNo = _redisDB,
TimeoutMilliseconds = 50
};
var cache = new RedisCacheProvider(config);
cache.Logger = new TestRedisLogger();
string key = "TagCacheTests:Add";
String value = "Hello World!";
DateTime expires = new DateTime(2099, 12, 11);
cache.Set(key, value, expires);
// no exception
}
public void Get_AddedObject_ReturnsValue()
{
var redis = new RedisConnectionManager();
var configuration = GetCacheConfiguration(redis);
var cache = new RedisCacheProvider(configuration);
cache.Logger = new TestRedisLogger();
string key = "TagCacheTests:Add";
var value = new TestObject()
{
Foo = "Hello",
Bar = "World",
Score = 11
};
DateTime expires = new DateTime(2099, 12, 11);
cache.Set(key, value, expires);
var result = cache.Get <TestObject>(key);
Assert.IsNotNull(result);
Assert.AreEqual(value.Foo, result.Foo);
Assert.AreEqual(value.Bar, result.Bar);
Assert.AreEqual(value.Score, result.Score);
}
static async System.Threading.Tasks.Task Main(string[] args)
{
Console.WriteLine("Hello World!");
var config = LoadConfig();
var oper = RedisCacheProvider.CreateInstance(config);
await oper.UpdateOrAddAsync <string>("lh", "Test");
}
protected override void ConfigureApplicationContainer(TinyIoCContainer container)
{
base.ConfigureApplicationContainer(container);
var loggingService = new StringBuilderLoggingService();
container.Register <ILoggingService>((c, p) => loggingService);
// Cache Level 1 - In Memory
ICacheProvider l1Cache = new InMemoryCacheProvider(
new MemoryCache("In-Memory Cache"),
loggingService);
// Cache Level 2 - Redis
ICacheProvider l2Cache = new RedisCacheProvider(
ConfigurationManager.AppSettings["RedisHost"],
loggingService,
new LoggingOptions
{
LogCacheMisses = true,
LogCacheHits = true
});
l2Cache.Delete("Test-Cache-Key");
container.Register <IDataService>(new DataService(
loggingService,
new[] { l1Cache, l2Cache }));
}
public void ShouldConstructSuccessfully()
{
// Arrange
var config = BuildCacheConfiguration(_redis);
config.RootNamespace = "_TestRootNamespace";
config.Serializer = new BinarySerializationProvider();
config.RedisClientConfiguration = new RedisClientConfiguration(config.RedisClientConfiguration.RedisConnectionManager)
{
DbIndex = DatabaseIndex,
TimeoutMs = 50
};
// Act
var cache = new RedisCacheProvider(config)
{
Logger = new TestRedisLogger()
};
var key = _fixture.FormatKey($"{Guid.NewGuid()}TagCacheTests:Add");
var expiry = DateTime.Now.AddSeconds(3);
const string value = "Test Value";
// Assert
Should.NotThrow(async() => await cache.SetItem(key, value, expiry).ConfigureAwait(false));
}
public static void UseRedisProvider()
{
var cacheProvider = new RedisCacheProvider();
cacheProvider.Set("k-name", "Redis Client");
Console.WriteLine(cacheProvider.Get <string>("k-name"));
}
public void GetPlayerWithEmptyStringReturnsNull()
{
_connectionMultiplexer = new Mock <IConnectionMultiplexer>();
_logger = new Mock <ILogger <RedisCacheProvider> >();
RedisCacheProvider _cache = new RedisCacheProvider(_connectionMultiplexer.Object, _logger.Object);
Assert.Null(_cache.GetPlayerAsync("").Result);
}
public RedisCacheProviderFacts()
{
manager = Substitute.For <IRedisClientsManager>();
client = Substitute.For <IRedisClient>();
sut = new RedisCacheProvider(manager);
manager.GetClient().Returns(client);
}
public void AsType_GivenInterfaceType_ShouldReturnExpectedDerivedClass()
{
ICacheProvider redisCacheProvider = new RedisCacheProvider();
redisCacheProvider
.AsType <RedisCacheProvider>()
.Should()
.BeOfType <RedisCacheProvider>();
}
public void AddValueToCache_NoExpiration()
{
var redisCacheProvider = new RedisCacheProvider(connection.GetDatabase(), connection.GetServer("127.0.0.1:6379"));
redisCacheProvider.Add(Key, Value);
var valueFromCache = redisCacheProvider.Get <string>(Key);
Assert.Equal(Value, valueFromCache);
}
public void EnsureCacheWithExactLifeTime_ReturnCorrectObject()
{
var redisCacheProvider = new RedisCacheProvider(connection.GetDatabase(), connection.GetServer("127.0.0.1:6379"));
redisCacheProvider.EnsureWithExactLifetime(Key, new TimeSpan(0, 0, 20), () => { return(Value); });
var valueFromCache = redisCacheProvider.Get <string>(Key);
Assert.Equal(Value, valueFromCache);
}
public void ContainKey_ReturnTrueAfterAddItem()
{
var redisCacheProvider = new RedisCacheProvider(connection.GetDatabase(), connection.GetServer("127.0.0.1:6379"));
redisCacheProvider.Add(Key, Value);
var containKeyInCache = redisCacheProvider.Contains(Key);
Assert.True(containKeyInCache);
}
public void AddWithSlidingLifetime_ExpireAfter20Seconds()
{
var redisCacheProvider = new RedisCacheProvider(connection.GetDatabase(), connection.GetServer("127.0.0.1:6379"));
redisCacheProvider.AddWithSlidingLifetime(Key, Value, new TimeSpan(0, 0, 20));
var valueFromCache = redisCacheProvider.Get <string>(Key);
Assert.Equal(Value, valueFromCache);
}
private static void TrySetMultiplexer()
{
if (Initialized)
{
return;
}
RedisCacheProvider.SetConnectionMultiplexer(Multiplexer);
Multiplexer.GetDatabase();
Initialized = true;
}
public ExpiryTests(TestFixture fixture)
{
_config = new CacheConfiguration(fixture.ThrowIfNull(nameof(fixture)).RedisConnectionManager);
_sut = new RedisCacheProvider(_config)
{
Logger = new TestRedisLogger()
};
_fixture = fixture;
}
public RedisProviderTest()
{
_autoMock = AutoMock.GetLoose();
redisCache = _autoMock.Create <RedisCacheProvider>(new TypedParameter(typeof(CacheOption), new CacheOption()
{
IpAddress = "192.168.180.55",
Password = "******"
}));
}
static void Main(string[] args)
{
var clientManager = new BasicRedisClientManager("localhost:6379");
using (var client = clientManager.GetClient())
{
client.FlushDb();
}
RedisCacheProvider.SetClientManager(clientManager);
// ClientManager = new BasicRedisClientManager(ValidHost);
//Redis = ClientManager.GetClient();
//Redis.FlushDb();
using (var session = NHibernateSessionFactory.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
var DepartmentObject = new Department {
Name = "IT", PhoneNumber = "962788700227"
};
session.Save(DepartmentObject);
transaction.Commit();
Console.WriteLine("Department Created: " + DepartmentObject.Name);
Console.ReadLine();
Department departmentAlias = null;
var query = session.QueryOver <Employee>()
.JoinAlias(x => x.EmployeeDepartment, () => departmentAlias, JoinType.LeftOuterJoin).Cacheable();
var c = query.List();
var d = query.List();
Console.WriteLine("Employee Listed: " + query.SingleOrDefault().FirstName);
Console.ReadLine();
}
}
using (var session = NHibernateSessionFactory.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
Department departmentAlias = null;
var query = session.QueryOver <Employee>()
.JoinAlias(x => x.EmployeeDepartment, () => departmentAlias, JoinType.LeftOuterJoin).Cacheable();
var c = query.List();
var d = query.List();
Console.WriteLine("Employee Listed: " + query.SingleOrDefault().FirstName);
Console.ReadLine();
}
}
}
public void Set_String_Succeeds()
{
var redis = new RedisConnectionManager();
var cache = new RedisCacheProvider(redis);
string key = "TagCacheTests:Add";
String value = "Hello World!";
DateTime expires = new DateTime(2099, 12, 11);
cache.Set(key, value, expires);
// no exception
}
public void OverwriteTest() {
var key = Guid.NewGuid().ToString("n");
var val = Guid.NewGuid();
IHttpRuntimeCacheProvider cacheProvider = new RedisCacheProvider(new ServiceStackRedis());
var result = cacheProvider.GetOrCreate<Guid>(key, () => val);
Assert.AreEqual(result, val);
var val2 = Guid.NewGuid();
cacheProvider.Overwrite<Guid>(key, val2);
Guid val3;
var exist = cacheProvider.TryGet<Guid>(key, out val3);
Assert.IsTrue(exist);
Assert.AreEqual(val3, val2);
}
public ActionResult Index()
{
if (Logger == null)
{
Logger = new ListLogger();
}
var stopwatch = new Stopwatch();
var result = new MyViewModel();
stopwatch.Start();
var cache = new RedisCacheProvider(RedisConnection);
cache.Logger = Logger;
stopwatch.Stop();
result.SetupTimeMs = stopwatch.ElapsedMilliseconds;
stopwatch.Reset();
stopwatch.Start();
var item = cache.Get<Models.SampleModel>("models:sample1");
if (item == null)
{
item = new SampleModel()
{
DateOfBirth = DateTime.Now,
Name = "Hello",
Surname = "World",
Other = new List<OtherModels>()
{
new OtherModels(){Foo = 1, Bar = 20.928},
new OtherModels(){Foo = 31, Bar = 30.3328},
}
};
cache.Set("models:sample1", item, DateTime.Now.AddSeconds(5), new List<string>(){"Test1", "Test2"});
}
stopwatch.Stop();
result.LoadTimeMs = stopwatch.ElapsedMilliseconds;
result.Data = item;
return View(result);
}
public void Ctor_Configuration__Fails()
{
var redis = new RedisConnectionManager("localhost");
var config = NewCacheConfiguration(redis);
config.RedisClientConfiguration = new RedisClientConfiguration(redis)
{
Host = "nohost",
TimeoutMilliseconds = 500
};
var cache = new RedisCacheProvider(config);
cache.Logger = new TestRedisLogger();
string key = "TagCacheTests:Add";
String value = "Hello World!";
DateTime expires = new DateTime(2099, 12, 11);
cache.Set(key, value, expires);
Assert.Fail("Exception should be thrown with bad connections");
}
public void OverwriteWithslidingExpirationTest() {
var key = Guid.NewGuid().ToString("n");
var val = Guid.NewGuid();
IHttpRuntimeCacheProvider cacheProvider = new RedisCacheProvider(new ServiceStackRedis());
//DateTime.Now
Guid result;
cacheProvider.Overwrite(key, val, TimeSpan.FromSeconds(8D));
{
Thread.Sleep(TimeSpan.FromSeconds(5D));
var exist = cacheProvider.TryGet<Guid>(key, out result);
Assert.IsTrue(exist);
Assert.AreEqual(result, val);
}
{
Thread.Sleep(TimeSpan.FromSeconds(5D));
var exist = cacheProvider.TryGet<Guid>(key, out result);
Assert.IsFalse(exist);
}
}
public void GetOrCreateTest() {
var key = Guid.NewGuid().ToString("n");
var val = Guid.NewGuid();
IHttpRuntimeCacheProvider cacheProvider = new RedisCacheProvider(new ServiceStackRedis());
var result = cacheProvider.GetOrCreate<Guid>(key, () => val);
Assert.AreEqual(result, val);
{
var exist = cacheProvider.TryGet<Guid>(key, out val);
Assert.IsTrue(exist);
Assert.AreEqual(result, val);
}
{
var result2 = cacheProvider.GetOrCreate<Guid>(key, () => {
Assert.Fail();
return Guid.NewGuid();
});
Assert.AreEqual(result2, val);
}
}
public void Ctor_Configuration__Succeeds()
{
var redis = new RedisConnectionManager("localhost");
var config = NewCacheConfiguration(redis);
config.RootNameSpace = "_TestRootNamespace";
config.Serializer = new BinarySerializationProvider();
config.RedisClientConfiguration = new RedisClientConfiguration(config.RedisClientConfiguration.RedisConnectionManagerConnectionManager)
{
Host = _redisHost,
DbNo = _redisDB,
TimeoutMilliseconds = 50
};
var cache = new RedisCacheProvider(config);
cache.Logger = new TestRedisLogger();
string key = "TagCacheTests:Add";
String value = "Hello World!";
DateTime expires = new DateTime(2099, 12, 11);
cache.Set(key, value, expires);
// no exception
}
public void Get_ExpiredDate_RemovesFromCache()
{
var redis = new RedisConnectionManager();
var cache = new RedisCacheProvider(redis);
cache.Logger = new TestRedisLogger();
string key = "TagCacheTests:Add";
String value = "Hello World!";
DateTime expires = new DateTime(2000, 12, 11);
cache.Set(key, value, expires);
var result = cache.Get<String>(key);
Assert.IsNull(result);
}
public void Get_ExpiredDate_RemovesTags()
{
var redis = new RedisConnectionManager();
var cache = new RedisCacheProvider(redis);
var config = NewCacheConfiguration(redis);
cache.Logger = new TestRedisLogger();
string key = "TagCacheTests:Add";
String value = "Hello World!";
var tag = "remove tag";
DateTime expires = new DateTime(2000, 12, 11);
cache.Set(key, value, expires, tag);
var test = cache.Get<String>(key);
var tagManager = new RedisTagManager(config.CacheItemFactory);
var result = tagManager.GetKeysForTag(newRedisClient(), tag);
Assert.AreEqual(result.Count(x => x == tag), 0);
}
public void GetByTag_SingleItemManyTags_ReturnsSingleValue()
{
var redis = new RedisConnectionManager();
var cache = new RedisCacheProvider(redis);
cache.Logger = new TestRedisLogger();
string key = "TagCacheTests:Add";
String value = "Hello World!";
DateTime expires = new DateTime(2099, 12, 11);
var tags = new List<string> { "tag1", "tag2", "tag3" };
cache.Set(key, value, expires, tags);
var results = cache.GetByTag<String>("tag2");
Assert.IsNotNull(results);
Assert.IsTrue(results.Count > 0);
}
public void RemoveByTag_ManyItemSingleTag_ReturnsNoValues()
{
var redis = new RedisConnectionManager();
var cache = new RedisCacheProvider(redis);
cache.Logger = new TestRedisLogger();
string key1 = "TagCacheTests:Add1";
string key2 = "TagCacheTests:Add2";
string key3 = "TagCacheTests:Add3";
String value1 = "Hello World!";
String value3 = "Two";
String value2 = "Three";
DateTime expires = new DateTime(2099, 12, 11);
var tags = new List<string> { "another tag" };
cache.Set(key1, value1, expires, tags);
cache.Set(key2, value2, expires, tags);
cache.Set(key3, value3, expires, tags);
var results = cache.GetByTag<String>(tags[0]);
Assert.IsNotNull(results);
Assert.AreEqual(results.Count, 3);
cache.RemoveByTag(tags[0]);
results = cache.GetByTag<String>(tags[0]);
Assert.IsNull(results);
}
public void CleanupExpiredKeys_RemovesOldItems()
{
var redis = new RedisConnectionManager(_redisHost);
var client = newRedisClient(redis);
var provider = new RedisCacheProvider(redis);
client.Remove(new RedisExpiryManager(new CacheConfiguration(redis))._setKey);
var expiryManager = new RedisExpiryManager(new CacheConfiguration(redis));
var key1 = "my.expiringkey.1";
var key2 = "my.expiringkey.2";
var key3 = "my.expiringkey.3";
expiryManager.SetKeyExpiry(client, key1, new DateTime(2012, 1, 1, 12, 1, 1));
expiryManager.SetKeyExpiry(client, key2, new DateTime(2015, 1, 1, 12, 1, 2));
expiryManager.SetKeyExpiry(client, key3, new DateTime(2020, 1, 1, 12, 1, 3));
var result = expiryManager.GetExpiredKeys(client, new DateTime(2020, 1, 1, 12, 1, 5));
Assert.IsNotNull(result);
Assert.IsTrue(result.Contains(key1), "key 1 should exist");
Assert.IsTrue(result.Contains(key2), "key 2 should exist");
Assert.IsTrue(result.Contains(key3), "key 3 should exist");
Assert.AreEqual(3, result.Count());
expiryManager.RemoveKeyExpiry(client, result);
result = expiryManager.GetExpiredKeys(client, new DateTime(2020, 1, 1, 12, 1, 5));
Assert.AreEqual(0, result.Count());
}
public void Get_MissingKey_ReturnsNull()
{
var redis = new RedisConnectionManager();
var cache = new RedisCacheProvider(redis);
cache.Logger = new TestRedisLogger();
string key = "TagCacheTests:NoValueHere." + DateTime.Now.Ticks;
var result = cache.Get<String>(key);
Assert.IsNull(result);
}
public void Get_AddedKey_ReturnsValue()
{
var redis = new RedisConnectionManager();
var cache = new RedisCacheProvider(redis);
cache.Logger = new TestRedisLogger();
string key = "TagCacheTests:Add";
String value = "Hello World!";
DateTime expires = new DateTime(2099, 12, 11);
cache.Set(key, value, expires);
var result = cache.Get<String>(key);
Assert.IsNotNull(result);
Assert.AreEqual(value, result);
}
public void Get_AddedObject_ReturnsValue()
{
var redis = new RedisConnectionManager();
var cache = new RedisCacheProvider(redis);
cache.Logger = new TestRedisLogger();
string key = "TagCacheTests:Add";
var value = new TestObject()
{
Foo = "Hello",
Bar = "World",
Score = 11
};
DateTime expires = new DateTime(2099, 12, 11);
cache.Set(key, value, expires);
var result = cache.Get<TestObject>(key);
Assert.IsNotNull(result);
Assert.AreEqual(value.Foo, result.Foo);
Assert.AreEqual(value.Bar, result.Bar);
Assert.AreEqual(value.Score, result.Score);
}
public void ItemExpires_Tag_RemovedFromCache()
{
// this is testing that when expiry happens, the events kick in and remove the tags
// see RedisExpireHandler
var redis = new RedisConnectionManager();
var config = new CacheConfiguration(redis);
var cache = new RedisCacheProvider(config);
var client = newRedisClient(config.RedisClientConfiguration);
cache.Logger = new TestRedisLogger();
Console.WriteLine("Start Logger");
string key = "TagCacheTests:ItemExpires_Tag_RemovedFromCache";
String value = "Hello World!";
DateTime expires = DateTime.Now.AddSeconds(3);
string tag1 = "tag1001";
string tag2 = "tag1002";
cache.Set(key, value, expires, new List<string>{tag1, tag2});
// first check everything has been set
var result = cache.Get<String>(key);
Assert.IsNotNull(result);
Assert.AreEqual(value, result);
var keysForTag1 = client.GetKeysForTag(tag1);
Assert.IsNotNull(keysForTag1);
Assert.IsTrue(keysForTag1.Any(x => x == key));
var tagsForKey = client.GetTagsForKey(key);
Assert.IsNotNull(tagsForKey);
Assert.IsTrue(tagsForKey.Any(x => x == tag1));
Assert.IsTrue(tagsForKey.Any(x => x == tag2));
// wait a while
Thread.Sleep(1000);
// check it has not expired yet
result = cache.Get<String>(key);
Assert.IsNotNull(result);
Assert.AreEqual(value, result);
keysForTag1 = client.GetKeysForTag(tag1);
Assert.IsNotNull(keysForTag1);
Assert.IsTrue(keysForTag1.Any(x => x == key));
tagsForKey = client.GetTagsForKey(key);
Assert.IsNotNull(tagsForKey);
Assert.IsTrue(tagsForKey.Any(x => x == tag1));
Assert.IsTrue(tagsForKey.Any(x => x == tag2));
// now wait until it should have been removed
Thread.Sleep(2500);
// now check its all been removed
result = cache.Get<String>(key);
Assert.IsNull(result);
keysForTag1 = client.GetKeysForTag(tag1);
Assert.IsNotNull(keysForTag1);
Assert.IsFalse(keysForTag1.Any(x => x == key));
tagsForKey = client.GetTagsForKey(key);
Assert.IsNotNull(tagsForKey);
Assert.IsFalse(tagsForKey.Any(x => x == tag1));
Assert.IsFalse(tagsForKey.Any(x => x == tag2));
}
