public void CanDeserializeSerializedConfiguration()
{
CacheManagerSettings settings = new CacheManagerSettings();
DataCacheStorageData data1 = new DataCacheStorageData(name1, database1, partition1);
settings.BackingStores.Add(data1);
// needed to save configuration
settings.CacheManagers.Add(new CacheManagerData("foo", 0, 0, 0, "storage"));
IDictionary <string, ConfigurationSection> sections = new Dictionary <string, ConfigurationSection>();
sections[CacheManagerSettings.SectionName] = settings;
IConfigurationSource configurationSource
= ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);
CacheManagerSettings roSettigs = (CacheManagerSettings)configurationSource.GetSection(CacheManagerSettings.SectionName);
Assert.IsNotNull(roSettigs);
Assert.AreEqual(1, roSettigs.BackingStores.Count);
Assert.IsNotNull(roSettigs.BackingStores.Get(name1));
Assert.AreSame(typeof(DataCacheStorageData), roSettigs.BackingStores.Get(name1).GetType());
Assert.AreEqual(name1, roSettigs.BackingStores.Get(name1).Name);
Assert.AreEqual(database1, ((DataCacheStorageData)roSettigs.BackingStores.Get(name1)).DatabaseInstanceName);
Assert.AreEqual(partition1, ((DataCacheStorageData)roSettigs.BackingStores.Get(name1)).PartitionName);
//Assert.AreEqual(encryption1, ((DataCacheStorageData)roSettigs.BackingStores.Get(name1)).StorageEncryption);
}
public void SetUp()
{
provider = new DataCacheStorageDataManageabilityProvider();
machineKey = new MockRegistryKey(true);
userKey = new MockRegistryKey(true);
configurationObject = new DataCacheStorageData();
}
/// <summary>
/// Creates node with specified data.
/// </summary>
/// <param name="dataCacheStorageData">Configuration data.</param>
public DataCacheStorageNode(DataCacheStorageData dataCacheStorageData)
: base(dataCacheStorageData)
{
this.dataCacheStorageData = dataCacheStorageData;
this.onInstanceNodeRemoved += new ConfigurationNodeChangedEventHandler(OnInstanceNodeRemoved);
this.onInstanceNodeRenamed += new ConfigurationNodeChangedEventHandler(OnInstanceNodeRenamed);
}
public void SetUp()
{
provider = new DataCacheStorageDataManageabilityProvider();
machineKey = new MockRegistryKey(true);
userKey = new MockRegistryKey(true);
configurationObject = new DataCacheStorageData();
}
/// <summary>
/// Initialize a new instance of the <see cref="DataCacheStorageNode"/> class with a <see cref="DataCacheStorageData"/> configuration object.
/// </summary>
/// <param name="dataCacheStorageData">A <see cref="DataCacheStorageData"/> configuration object</param>
public DataCacheStorageNode(DataCacheStorageData dataCacheStorageData)
{
if (null == dataCacheStorageData) throw new ArgumentNullException("dataCacheStorageData");
Rename(dataCacheStorageData.Name);
this.onConnectionNodeRemoved = new EventHandler<ConfigurationNodeChangedEventArgs>(OnConnectionStringSettingsNodeRemoved);
this.onConnectionNodeRenamed = new EventHandler<ConfigurationNodeChangedEventArgs>(OnConnectionStringSettingsRenamed);
this.partitionName = dataCacheStorageData.PartitionName;
this.connectionStringName = dataCacheStorageData.DatabaseInstanceName;
}
public StoreInDatabase(ICachingConfigurationCacheManager context, string backingStoreName)
: base(context)
{
dataCacheStore = new DataCacheStorageData
{
Name = backingStoreName
};
base.AddBackingStoreToCachingConfigurationAndCurrentCacheManager(dataCacheStore);
}
private DataBackingStore CreateDataBackingStore()
{
DataCacheStorageData data = new DataCacheStorageData();
data.DatabaseInstanceName = "CachingDatabase";
data.PartitionName = "Partition1";
DataBackingStore backingStore = new DataBackingStore();
backingStore.Initialize(new TestCachingConfigurationView(data, Context));
return(backingStore);
}
private DataBackingStore CreateBackingStore(string instanceName, string partitionName)
{
DataCacheStorageData data = new DataCacheStorageData();
data.DatabaseInstanceName = instanceName;
data.PartitionName = partitionName;
DataBackingStore backingStore = new DataBackingStore();
backingStore.Initialize(new TestCachingConfigurationView(data, Context));
return(backingStore);
}
public void CanReadCacheStorageObject()
{
XmlTextReader xmlReader = new XmlTextReader(new StringReader(configurationSection));
XmlSerializer xmlSerializer = new XmlSerializer(typeof(DataCacheStorageData));
DataCacheStorageData objectFromConfiguration = xmlSerializer.Deserialize(xmlReader) as DataCacheStorageData;
Assert.AreEqual("inIsolatedStorage", objectFromConfiguration.Name);
Assert.IsNotNull(objectFromConfiguration.TypeName);
Assert.IsNotNull(Type.GetType(objectFromConfiguration.TypeName));
Assert.AreEqual("Foo", objectFromConfiguration.DatabaseInstanceName);
Assert.AreEqual("Partition1", objectFromConfiguration.PartitionName);
}
/// <summary>
/// Initialize a new instance of the <see cref="DataCacheStorageNode"/> class with a <see cref="DataCacheStorageData"/> configuration object.
/// </summary>
/// <param name="dataCacheStorageData">A <see cref="DataCacheStorageData"/> configuration object</param>
public DataCacheStorageNode(DataCacheStorageData dataCacheStorageData)
{
if (null == dataCacheStorageData)
{
throw new ArgumentNullException("dataCacheStorageData");
}
Rename(dataCacheStorageData.Name);
this.onConnectionNodeRemoved = new EventHandler <ConfigurationNodeChangedEventArgs>(OnConnectionStringSettingsNodeRemoved);
this.onConnectionNodeRenamed = new EventHandler <ConfigurationNodeChangedEventArgs>(OnConnectionStringSettingsRenamed);
this.partitionName = dataCacheStorageData.PartitionName;
this.connectionStringName = dataCacheStorageData.DatabaseInstanceName;
}
public void CanConstructDataCacheStorageDataCorrectly()
{
const string name = "name";
const string instance = "instance";
const string partition = "partition";
DataCacheStorageData data = new DataCacheStorageData(name, instance, partition);
Assert.AreEqual(name, data.Name);
Assert.AreEqual(instance, data.DatabaseInstanceName);
Assert.AreEqual(partition, data.PartitionName);
Assert.AreEqual(typeof(DataBackingStore), data.Type);
}
public void DataTest()
{
string name = "testName";
string type = typeof(DataBackingStore).AssemblyQualifiedName;
DataCacheStorageData data = new DataCacheStorageData();
data.Name = name;
DataCacheStorageNode node = new DataCacheStorageNode(data);
CreateHierarchyAndAddToHierarchyService(node, CreateDefaultConfiguration());
Assert.AreEqual(name, node.Name);
Assert.AreEqual(type, node.Type);
}
public void DataTest()
{
string name = "testName";
string type = typeof(DataBackingStore).AssemblyQualifiedName;
DataCacheStorageData data = new DataCacheStorageData();
data.Name = name;
DataCacheStorageNode node = new DataCacheStorageNode(data);
CreateHierarchyAndAddToHierarchyService(node, CreateDefaultConfiguration());
Assert.AreEqual(name, node.Name);
Assert.AreEqual(type, node.Type);
}
/// <summary>
/// Initializes a new instance of the <see cref="DataBackingStore"/> class
/// with the specified configuration information.
/// </summary>
/// <param name="configurationView">A <see cref="CachingConfigurationView"></see> object</param>
/// <exception cref="System.Configuration.ConfigurationException">Reflects any failures to read configuration information</exception>
/// <remarks>Other exceptions thrown depend on the implementation of the underlying database.</remarks>
public override void Initialize(ConfigurationView configurationView)
{
ArgumentValidation.CheckForNullReference(configurationView, "configurationView");
ArgumentValidation.CheckExpectedType(configurationView, typeof(CachingConfigurationView));
CachingConfigurationView cachingConfigurationView = (CachingConfigurationView)configurationView;
DataCacheStorageData dataConfiguration = (DataCacheStorageData)cachingConfigurationView.GetCacheStorageDataForCacheManager(CurrentCacheManager);
partitionName = dataConfiguration.PartitionName;
DatabaseProviderFactory dataFactory = new DatabaseProviderFactory(cachingConfigurationView.ConfigurationContext);
database = dataFactory.CreateDatabase(dataConfiguration.DatabaseInstanceName);
if (dataConfiguration.StorageEncryption != null)
{
StorageEncryptionFactory encryptionFactory = new StorageEncryptionFactory(cachingConfigurationView.ConfigurationContext);
encryptionProvider = encryptionFactory.CreateSymmetricProvider(CurrentCacheManager);
}
}
public override void FixtureSetup()
{
base.FixtureSetup();
DataCacheStorageData firstCacheData = new DataCacheStorageData();
firstCacheData.DatabaseInstanceName = "CachingDatabase";
firstCacheData.PartitionName = "Partition1";
firstCache = new DataBackingStore();
firstCache.Initialize(new TestCachingConfigurationView(firstCacheData, Context));
DataCacheStorageData secondCacheData = new DataCacheStorageData();
secondCacheData.DatabaseInstanceName = "CachingDatabase";
secondCacheData.PartitionName = "Partition2";
secondCache = new DataBackingStore();
secondCache.Initialize(new TestCachingConfigurationView(secondCacheData, Context));
}
public void NodeTest()
{
string databaseInstanceName = "dabaseInstanceName";
string databasePartitionName = "databasePartitionName";
InstanceNode databaseNode = new InstanceNode(new InstanceData(databaseInstanceName));
DataCacheStorageNode node = new DataCacheStorageNode();
IUIHierarchy hierarchy = CreateHierarchyAndAddToHierarchyService(node, CreateDefaultConfiguration());
hierarchy.AddNode(databaseNode);
node.DatabaseInstance = databaseNode;
node.PartitionName = databasePartitionName;
Assert.AreEqual(databaseInstanceName, node.DatabaseInstance.Name);
DataCacheStorageData nodeData = (DataCacheStorageData)node.CacheStorageData;
Assert.AreEqual(databaseInstanceName, nodeData.DatabaseInstanceName);
}
public void CanResolveDataBackingStoreWithOutEncryptionProvider()
{
const string key = "fooKey";
DataCacheStorageData data = new DataCacheStorageData("Data Cache Storage", "CachingDatabase", "fooPartition");
settings.BackingStores.Add(data);
CacheManagerData managerData = new CacheManagerData("defaultCacheManager", 300, 200, 100, "Data Cache Storage");
settings.CacheManagers.Add(managerData);
settings.DefaultCacheManager = "defaultCacheManager";
dbSettings.DefaultDatabase = "CachingDatabase";
container = EnterpriseLibraryContainer.CreateDefaultContainer(configurationSource);
DataBackingStore createdStore = container.GetInstance <DataBackingStore>("Data Cache Storage");
Assert.IsNotNull(createdStore);
createdStore.Add(new CacheItem(key, 1, CacheItemPriority.Low, null, null));
Assert.AreEqual(1, createdStore.Count);
createdStore.Remove(key);
Assert.AreEqual(0, createdStore.Count);
}
/// <summary>
/// Creates node with specified data.
/// </summary>
/// <param name="dataCacheStorageData">Configuration data.</param>
public DataCacheStorageNode(DataCacheStorageData dataCacheStorageData) : base(dataCacheStorageData)
{
this.dataCacheStorageData = dataCacheStorageData;
this.onInstanceNodeRemoved += new ConfigurationNodeChangedEventHandler(OnInstanceNodeRemoved);
this.onInstanceNodeRenamed += new ConfigurationNodeChangedEventHandler(OnInstanceNodeRenamed);
}
