public PerfomanceTwoLayerRealCacheTest()
{
var connectionString = ConfigurationManager.AppSettings["RedisConnectionString"];
MemoryCacheImpl cacheLayer1 = new MemoryCacheImpl("PerfomanceTwoLayerRealCacheTest");
RedisCacheImpl cacheLayer2 = new RedisCacheImpl("PerfomanceTwoLayerRealCacheTest", connectionString);
RedisMessageBus messageBus = new RedisMessageBus(connectionString);
_testCache = new TwoLayerCacheImpl(cacheLayer1, cacheLayer2, messageBus);
}
public void SetUp()
{
var connectionString = ConfigurationManager.AppSettings["RedisConnectionString"];
_cacheLayer1 = new MemoryCacheImpl("TwoLayerCacheRealMemoryTest");
_cacheLayer2 = new RedisCacheImpl("TwoLayerCacheRealMemoryTest", connectionString);
_messageBus = new RedisMessageBus(connectionString);
_testCache = new TwoLayerCacheImpl(_cacheLayer1, _cacheLayer2, _messageBus);
}
private static void GenerateRemoveKeyInstance(string key, string hostName, int port, string password, Mock <IResourceCatalog> mockResourceCatalog, out TestRedisRemoveActivity sut)
{
var impl = new RedisCacheImpl(hostName, port, password);
sut = new TestRedisRemoveActivity(mockResourceCatalog.Object, impl)
{
Key = key,
};
}
private IDictionary <string, string> GetCachedData(RedisCacheImpl impl, string key)
{
var actualCacheData = impl.Get(key);
if (actualCacheData != null)
{
var serializer = new Dev2JsonSerializer();
return(serializer.Deserialize <IDictionary <string, string> >(actualCacheData));
}
return(null);
}
public void TearDown()
{
_testCache.Dispose();
_messageBus.Dispose();
_cacheLayer1.Dispose();
_cacheLayer2.Dispose();
_testCache = null;
_messageBus = null;
_cacheLayer1 = null;
_cacheLayer2 = null;
}
private static void CreateRedisActivity(string key, string hostName, int port, string password, Mock <IResourceCatalog> mockResourceCatalog, out TestRedisActivity sut, Activity innerActivity)
{
var impl = new RedisCacheImpl(hostName, port, password);
sut = new TestRedisActivity(mockResourceCatalog.Object, impl)
{
Key = key,
TTL = 30,
ActivityFunc = new ActivityFunc <string, bool>
{
Handler = innerActivity
}
};
}
public void SetUp()
{
var cacheName = GetType().Name;
var settings = new RedisConnectionSettings
{
Host = "localhost",
Password = "******"
};
var log = new Mock <ILog>().Object;
var performanceLog = new Mock <IPerformanceLog>().Object;
_cache = new RedisCacheImpl(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
}
public void MemoryTest(int iterations)
{
// Given
var cacheName = GetType().Name;
var settings = new RedisConnectionSettings
{
Host = "localhost",
Password = "******"
};
var log = new Mock <ILog>().Object;
var performanceLog = new Mock <IPerformanceLog>().Object;
var memoryCache = new MemoryCacheImpl(cacheName);
var redisCache = new RedisCacheImpl(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
var redisMessageBusManager = new RedisMessageBusManager(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
var redisMessageBusPublisher = new RedisMessageBusPublisher(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
var redisMessageBus = new MessageBusImpl(redisMessageBusManager, redisMessageBusPublisher);
var twoLayerCache = new TwoLayerCacheImpl(memoryCache, redisCache, redisMessageBus);
const string key = "GetMemoryTest_Key";
double startSize = GC.GetTotalMemory(true);
// When
var cache = twoLayerCache;
for (var i = 0; i < iterations; ++i)
{
var value = Guid.NewGuid().ToString("N");
cache.Set(key, value);
cache.Get(key);
}
cache.Dispose();
double stopSize = GC.GetTotalMemory(true);
var memoryLeak = (stopSize - startSize);
// Then
Console.WriteLine(@"Iteration count: {0}", iterations);
Console.WriteLine(@"Memory Leak : {0:N2} %", memoryLeak / startSize);
Console.WriteLine(@"Memory Leak : {0:N2} Kb", memoryLeak / 1024);
}
private static void GenerateAddKeyInstance(string key, string hostName, int port, string password, Mock <IResourceCatalog> mockResourceCatalog, out Dictionary <string, string> eval, out TestRedisActivity sut, Activity innerActivity)
{
eval = new Dictionary <string, string> {
{ "", "" }
};
var impl = new RedisCacheImpl(hostName, port, password);
sut = new TestRedisActivity(mockResourceCatalog.Object, impl)
{
Key = key,
TTL = 3000,
ActivityFunc = new ActivityFunc <string, bool>
{
Handler = innerActivity
}
};
}
private List <SpecAssignValue> GetCachedData(RedisCacheImpl impl, string key)
{
var activities = new List <SpecAssignValue>();
var actualCacheData = impl.Get(key);
if (actualCacheData != null)
{
var serializer = new Dev2JsonSerializer();
var actualData = serializer.Deserialize <IDictionary <string, string> >(actualCacheData);
foreach (var item in actualData)
{
activities.Add(new SpecAssignValue {
Name = item.Key, Value = item.Value
});
}
}
return(activities);
}
public void SetUp()
{
var cacheName = GetType().Name;
var settings = new RedisConnectionSettings
{
Host = "localhost",
Password = "******"
};
var log = new Mock <ILog>().Object;
var performanceLog = new Mock <IPerformanceLog>().Object;
var memoryCache = new MemoryCacheImpl(cacheName);
var redisCache = new RedisCacheImpl(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
var redisMessageBusManager = new RedisMessageBusManager(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
var redisMessageBusPublisher = new RedisMessageBusPublisher(cacheName, new RedisConnectionFactory(settings), log, performanceLog);
var redisMessageBus = new MessageBusImpl(redisMessageBusManager, redisMessageBusPublisher);
var twoLayerCache = new TwoLayerCacheImpl(memoryCache, redisCache, redisMessageBus);
_cache = twoLayerCache;
}
public void TearDown()
{
_testCache.Dispose();
_testCache = null;
}
public void SetUp()
{
var connectionString = ConfigurationManager.AppSettings["RedisConnectionString"];
_testCache = new RedisCacheImpl("RedisLayerCacheTest",connectionString);
}
private static SpecRedisActivity GetRedisActivity(IResourceCatalog resourceCatalog, string key, int ttl, string hostName, RedisCacheImpl impl, DsfMultiAssignActivity assignActivity)
{
Stoptime = Stopwatch.StartNew();
return(new SpecRedisActivity(resourceCatalog, impl)
{
Key = key,
ActivityFunc = new ActivityFunc <string, bool> {
Handler = assignActivity
},
TTL = ttl,
RedisSource = new Dev2.Data.ServiceModel.RedisSource {
HostName = hostName
},
});
}
private static SpecRedisRemoveActivity GetRedisRemoveActivity(IResourceCatalog resourceCatalog, string key, string hostName, RedisCacheImpl impl)
{
return(new SpecRedisRemoveActivity(resourceCatalog, impl)
{
Key = key,
RedisSource = new Dev2.Data.ServiceModel.RedisSource {
HostName = hostName
},
});
}
public void SetUp()
{
var connectionString = ConfigurationManager.AppSettings.Get("RedisConnectionString");
_cache = new RedisCacheImpl("TestNamespace", connectionString);
}
private static SpecRedisActivity ExecuteRedisActivity(string hostName, string password, int port, string key, int ttl, RedisCacheImpl impl, DsfMultiAssignActivity assignActivity)
{
var environment = new ExecutionEnvironment();
GenResourceAndDataobject(key, hostName, password, port);
var redisActivity = SetupRedisActivity(_mockResourceCatalog.Object, key, ttl, hostName, impl, assignActivity);
ExecuteCacheTool(redisActivity, _mockDataobject);
var executionResult = redisActivity.SpecPerformExecution(new Dictionary <string, string> {
{ "", "" }
});
Assert.AreEqual("Success", executionResult[0]);
return(redisActivity);
}
public PerfomanceRedisLayerCacheTest()
{
var connectionString = ConfigurationManager.AppSettings["RedisConnectionString"];
_testCache = new RedisCacheImpl("PerfomanceRedisLayerCacheTest", connectionString);
}
public TestRedisActivity(IResourceCatalog resourceCatalog, RedisCacheImpl impl)
: base(resourceCatalog, impl)
{
}
