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); }
/// <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); }
/// <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); }