public void CreateCacheData_TestMethod()
{
var mockCacheController = new Mock <ICacheController> {
CallBase = true
};
CacheFactory.CreateCacheData(mockCacheController.Object, typeof(TestCacheData));
mockCacheController.Verify(m => m.Add(It.IsAny <CacheDataController>()), Times.Once());
}
public void LoadPersistent()
{
if (Controller.EmptyByType(typeof(SettingsCacheData)))
{
CacheFactory.CreateCacheData(Controller, typeof(SettingsCacheData));
}
if (Controller.EmptyByType(typeof(FavoriteFileCache)))
{
CacheFactory.CreateCacheData(Controller, typeof(FavoriteFileCache));
}
}
public void Load()
{
Controller = new CacheController();
var dataStore2 = new XmlCacheDataStore {
Path = DataFile
};
Controller.SetupDataStore(dataStore2);
Controller.Load();
if (Controller.EmptyByType(typeof(OptionsCacheData)))
{
CacheFactory.CreateCacheData(Controller, typeof(OptionsCacheData));
}
if (Controller.EmptyByType(typeof(CategoryCacheData)))
{
CacheFactory.CreateCacheData(Controller, typeof(CategoryCacheData));
}
if (Controller.EmptyByType(typeof(HideOptionCacheData)))
{
CacheFactory.CreateCacheData(Controller, typeof(HideOptionCacheData));
}
if (Controller.EmptyByType(typeof(PatternCacheData)))
{
CacheFactory.CreateCacheData(Controller, typeof(PatternCacheData));
}
if (Controller.EmptyByType(typeof(EventCacheData)))
{
CacheFactory.CreateCacheData(Controller, typeof(EventCacheData));
}
if (Controller.EmptyByType(typeof(ValueCacheData)))
{
CacheFactory.CreateCacheData(Controller, typeof(ValueCacheData));
}
if (Controller.EmptyByType(typeof(ResearchCacheData)))
{
CacheFactory.CreateCacheData(Controller, typeof(ResearchCacheData));
}
if (Controller.EmptyByType(typeof(NetworkMapCacheData)))
{
CacheFactory.CreateCacheData(Controller, typeof(NetworkMapCacheData));
}
_loaded.Set();
}
private static CacheController PrepareCache(out MemoryCacheDataStore dataStore, out CacheDataController data)
{
var cache = new CacheController();
dataStore = new MemoryCacheDataStore();
cache.SetupDataStore(dataStore);
data = CacheFactory.CreateCacheData(cache, typeof(TestCacheData));
// The following line of code will force a reload
var testData = data.Data as TestCacheData;
Assert.IsNotNull(testData, "Test Data should not be null");
testData.Model = MODEL_DATA;
// This will return us to an IsCached = false state - Sara
cache.Invalidate();
return cache;
}
public CacheDataController InitializeFile(string path, ref BuildInitializeFileDetail result)
{
var _result = new BuildInitializeFileDetail();
var start = DateTime.Now;
CacheDataController cacheDataController;
var lockWait = DateTime.Now;
lock (Controller)
{
_result.LockWaitDuration = (DateTime.Now - lockWait);
var startGetData = DateTime.Now;
cacheDataController = Controller.GetData(path, typeof(FileData)).FirstOrDefault() ??
CacheFactory.CreateCacheData(Controller, typeof(FileData));
_result.GetDataDuration = DateTime.Now - startGetData;
}
if (cacheDataController == null)
{
return(null);
}
#region Initialize
var start2 = DateTime.Now;
var internalFile = cacheDataController.InternalData as FileData;
// If the Data is not cached then create a FileData for first time use
// Otherwise use the Cached version - Sara
if (internalFile == null || internalFile.Path == null)
{
internalFile = new FileData {
Path = path
}
}
;
cacheDataController.Initialize(internalFile);
PrepareFileEvents(cacheDataController);
_result.InitializeDuration = DateTime.Now - start2;
#endregion
_result.InitializeFileDuration = DateTime.Now - start;
result = _result;
return(cacheDataController);
}
private CacheDataController InitializeReport <T>(string name) where T : class, ICacheData
{
lock (Controller)
{
var cacheDataController = Controller.GetData(name, typeof(T)).FirstOrDefault() ??
CacheFactory.CreateCacheData(Controller, typeof(T));
if (cacheDataController == null)
{
return(null);
}
if (cacheDataController.InternalData.Key == null)
{
cacheDataController.InternalData.Key = name;
}
var internalReport = cacheDataController.InternalData as T;
cacheDataController.Initialize(internalReport);
return(cacheDataController);
}
}