public void CanSaveConfigurationSectionToFile()
{
FileConfigurationSource source = new FileConfigurationSource(file, false);
source.Save(InstrumentationConfigurationSection.SectionName, CreateInstrumentationSection());
ValidateConfiguration(file);
}
public void TryToSaveWithAFileConfigurationSaveParameter()
{
FileConfigurationSource source = new FileConfigurationSource(file, false);
source.Add(InstrumentationConfigurationSection.SectionName, CreateInstrumentationSection());
ValidateConfiguration(file);
}
public static ValidationResults Validate(object objectToValidate)
{
FileConfigurationSource fileConfigurationsource = new FileConfigurationSource(validationFilePath);
Validator validator = ValidationFactory.CreateValidator(objectToValidate.GetType(), objectToValidate.GetType().Name, fileConfigurationsource);
var validationResult = validator.Validate(objectToValidate);
return validationResult;
}
public void then_attributes_with_omitted_values_are_overridden()
{
FileConfigurationSource source = new FileConfigurationSource(TargetFile);
LoggingSettings settings = (LoggingSettings)source.GetSection(LoggingSettings.SectionName);
Assert.IsFalse(settings.RevertImpersonation);
Assert.IsFalse(settings.LogWarningWhenNoCategoriesMatch);
}
public static List<ValidatorData> ExtractRules(this Type targetType, string propertyName)
{
FileConfigurationSource fileConfigurationsource = new FileConfigurationSource(validationFilePath);
ValidationSettings settings = (ValidationSettings)fileConfigurationsource.GetSection("validation");
ValidatedTypeReference rules = settings.Types.FirstOrDefault(item => item.Name.Equals(targetType.FullName));
return rules.Rulesets.SelectMany(item => item.Properties).Where(item => item.Name.Equals(propertyName)).SelectMany(item => item.Validators).ToList();
}
protected void ProtectSection(FileConfigurationSource source, string sectionName, string protectionProvider)
{
ConfigurationSectionCloner cloner = new ConfigurationSectionCloner();
var section = source.GetSection(sectionName);
section = cloner.Clone(section);
source.Remove(sectionName);
source.Add(sectionName, section, protectionProvider);
}
protected override void Arrange()
{
base.Arrange();
using (var source = new FileConfigurationSource(mainConfigurationFile))
{
ProtectSection(source, LoggingSettings.SectionName, "RsaProtectedConfigurationProvider");
}
}
protected override void Arrange()
{
base.Arrange();
var configurationFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "unity.config");
var source = new FileConfigurationSource(configurationFilePath);
sectionToClone = (UnityConfigurationSection)source.GetSection("unity");
//editableSection = (UnityConfigurationSection)base.UnitySectionViewModel.ConfigurationElement;
//editableSection.TypeAliases.Add(new AliasElement("alias1", typeof(int)));
//editableSection.TypeAliases.Add(new AliasElement("alias2", typeof(string)));
//editableSection.Containers.Add(new ContainerElement()
//{
// Name = "cloned",
// Registrations = {{
// new RegisterElement
// {
// Name = "Registration1",
// TypeName = "RegistrationTypeName",
// InjectionMembers = {{
// new PropertyElement
// {
// Name = "Property1",
// Value = new ValueElement
// {
// Value = "PropertyValue"
// }
// }
// },
// {
// new ConstructorElement
// {
// Parameters =
// {{
// new ParameterElement
// {
// Name = "array",
// Value = new ArrayElement
// {
// TypeName = "t",
// Values = {{new ArrayElement()},{new ValueElement
// {
// Value = "v"
// }}}
// }
// }
// }}
// }
// }}
// }}}
//});
cloner = new ConfigurationSectionCloner();
}
public void then_file_has_overridden_values()
{
FileConfigurationSource source = new FileConfigurationSource(TargetFile);
LoggingSettings settings = (LoggingSettings)source.GetSection(LoggingSettings.SectionName);
FormattedEventLogTraceListenerData traceListener = (FormattedEventLogTraceListenerData)settings.TraceListeners.Get("Event Log Listener");
Assert.AreEqual(TraceOptions.ProcessId, traceListener.TraceOutputOptions);
Assert.AreEqual("overridden source", traceListener.Source);
Assert.AreEqual("overridden machine", traceListener.MachineName);
}
public void then_file_has_overridden_values()
{
FileConfigurationSource source = new FileConfigurationSource(TargetFile);
CacheManagerSettings settings = (CacheManagerSettings)source.GetSection(CacheManagerSettings.SectionName);
CacheManagerData cacheManager = (CacheManagerData)settings.CacheManagers.Get("Cache Manager");
Assert.AreEqual(1, cacheManager.MaximumElementsInCacheBeforeScavenging);
Assert.AreEqual(1, cacheManager.NumberToRemoveWhenScavenging);
Assert.AreEqual(1, cacheManager.ExpirationPollFrequencyInSeconds);
}
protected override void Act()
{
var resources = new ResourceHelper<ConfigFileLocator>();
var deltaConfigurationFile = resources.DumpResourceFileToDisk("override_lab_protection_dpapi.dconfig");
ConfigurationMerger configurationMerger = new ConfigurationMerger(mainConfigurationFile, deltaConfigurationFile);
configurationMerger.MergeConfiguration(mergedConfigurationFile);
mergedConfigurationFileSource = new FileConfigurationSource(mergedConfigurationFile);
}
public void SkipsInjectorsElement()
{
using (var source = new FileConfigurationSource("OldStyle.config", false))
{
PolicyInjectionSettings settings
= (PolicyInjectionSettings)source.GetSection(PolicyInjectionSettings.SectionName);
Assert.IsNotNull(settings);
Assert.AreEqual(3, settings.Policies.Count);
}
}
/// <summary>
/// Initializes the specified configuration files, we only use the first found one
/// </summary>
/// <param name="configFiles">All the potential configuration files, order by priority.</param>
/// <returns></returns>
public override bool Initialize(string[] configFiles)
{
if (!base.Initialize(configFiles))
return false;
var configurationSource = new FileConfigurationSource(this.ConfigFile);
var factory = new LogWriterFactory(configurationSource);
m_LogWriter = factory.Create();
return true;
}
public void then_removed_sections_are_removed_when_saving()
{
ConfigurationSourceModel sourceModel = Container.Resolve<ConfigurationSourceModel>();
var loggingSettings = sourceModel.Sections.Where(x => x.ConfigurationType == typeof(LoggingSettings)).First();
loggingSettings.Delete();
ApplicationModel.Save();
FileConfigurationSource source = new FileConfigurationSource(TestConfigurationFilePath, false);
Assert.IsNull(source.GetSection(LoggingSettings.SectionName));
}
/// <summary>
/// Initializes a new instance of the <see cref="EntLib5Factory"/> class.
/// </summary>
/// <param name="EntLib5ConfigurationFile">The enterprise library 5.0 configuration file to load and watch. Supercedes any configuration found in the Config file.</param>
public EntLib5Factory(string EntLib5ConfigurationFile)
{
// verify provided file exists
var fi = new System.IO.FileInfo(EntLib5ConfigurationFile);
if (fi.Exists)
{
var builder = new ConfigurationSourceBuilder();
var EntLib5ConfigurationSrc = new FileConfigurationSource(EntLib5ConfigurationFile, true);
builder.UpdateConfigurationWithReplace(EntLib5ConfigurationSrc);
EnterpriseLibraryContainer.Current = EnterpriseLibraryContainer.CreateDefaultContainer(EntLib5ConfigurationSrc);
}
}
public void ThenThrowsExceptionWhenTypeIsInvalid()
{
try
{
IConfigurationSource config = new FileConfigurationSource(configurationFilePath);
var sources = config.GetSection("enterpriseLibrary.ConfigurationSource");
Assert.Fail("Should have thrown");
}
catch (ConfigurationException ex)
{
Assert.IsTrue(ex.Message.Contains("The type 'Microsoft.Practices.EnterpriseLibrary.Common.Configuration.InvalidType, Microsoft.Practices.EnterpriseLibrary.Common' defined in the 'InvalidType' configuration source is invalid"));
}
}
public void ShouldLogOnlyToCategoriesGivenInConfig()
{
using (var configSource = new FileConfigurationSource("LogCallHandler.config", false))
{
using (var eventLog = new EventLogTracker("Application"))
{
using (var injector = new PolicyInjector(configSource))
{
LoggingTarget target = injector.Create<LoggingTarget>();
target.DoSomething(1, "two", 3.0);
}
Assert.AreEqual(1, eventLog.NewEntries().Select(le => le.Category == "Default Category").Count());
}
}
}
private static FileConfigurationSource GetFileConfigurationSource(string SourceName)
{
//获取App.config
Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
//获取资源节点集合
ConfigurationSourceSection section =
(ConfigurationSourceSection)config.GetSection(ConfigurationSourceSection.SectionName);
//获取重定向配置文件资源配置节点
FileConfigurationSourceElement elem =
(FileConfigurationSourceElement)section.Sources.Get(SourceName);
//获取重定向配置文件资源
FileConfigurationSource fileSource = new FileConfigurationSource(elem.FilePath);
return fileSource;
}
public void AssembledCorrectlyLogCallHandler()
{
using (var configSource = new FileConfigurationSource("LogCallHandler.config", false))
{
Logger.SetLogWriter(new LogWriterFactory(configSource.GetSection).Create(), false);
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policyData = new PolicyData("policy");
LogCallHandlerData data = new LogCallHandlerData("fooHandler", 66);
data.BeforeMessage = "before";
data.AfterMessage = "after";
data.IncludeCallTime = true;
data.EventId = 100;
data.Categories.Add(new LogCallHandlerCategoryEntry("category1"));
data.Categories.Add(new LogCallHandlerCategoryEntry("category2"));
policyData.MatchingRules.Add(new CustomMatchingRuleData("matchesEverything", typeof(AlwaysMatchingRule)));
policyData.Handlers.Add(data);
settings.Policies.Add(policyData);
using (var container = new UnityContainer().AddNewExtension<Interception>())
{
settings.ConfigureContainer(container);
var policy = container.Resolve<InjectionPolicy>("policy");
LogCallHandler handler = (LogCallHandler)
(policy.GetHandlersFor(GetMethodImpl(MethodBase.GetCurrentMethod()), container)).ElementAt(0);
Assert.IsNotNull(handler);
Assert.AreEqual(66, handler.Order);
Assert.AreEqual("before", handler.BeforeMessage);
Assert.AreEqual("after", handler.AfterMessage);
Assert.AreEqual(true, handler.IncludeCallTime);
Assert.AreEqual(100, handler.EventId);
Assert.AreEqual(2, handler.Categories.Count);
CollectionAssert.Contains(handler.Categories, "category1");
CollectionAssert.Contains(handler.Categories, "category2");
}
}
}
public void ShouldCombineWithPoliciesDefinedInConfiguration()
{
using (var configSource = new FileConfigurationSource("CombinesWithConfig.config", false))
{
using (var eventLog = new EventLogTracker("Application"))
{
using (var injector = new PolicyInjector(configSource))
{
var typeWhichUndergoesLoggingOnMethodCall =
injector.Create<TypeWhichUndergoesAttributeBasedLogging>();
typeWhichUndergoesLoggingOnMethodCall.TestMethod();
typeWhichUndergoesLoggingOnMethodCall.MyProperty = "hello";
}
Assert.AreEqual(2,
eventLog.NewEntries().Select(le => le.Message.Contains("This is before the call")).
Count());
}
}
}
public void WhenRetrievingAPiabConfigElementPresentInBothSources()
{
var configSource = new FileConfigurationSource("main.config");
var piab = configSource.GetSection(PolicyInjectionSettings.SectionName) as PolicyInjectionSettings;
Assert.IsNotNull(piab);
Assert.AreEqual(3, piab.Policies.Count);
var policy = piab.Policies.Get("Merged Policy");
Assert.AreEqual(1, policy.MatchingRules.Count);
var matchingRule = (MemberNameMatchingRuleData)policy.MatchingRules.Get(0);
Assert.AreEqual(2, matchingRule.Matches.Count);
var member = matchingRule.Matches[1];
Assert.IsFalse(member.IgnoreCase);
}
public void TestInitialize()
{
authorizationConfiguration = new FileConfigurationSource("Authorization.config", false);
var securitySettings = (SecuritySettings)authorizationConfiguration.GetSection(SecuritySettings.SectionName);
AllowFredPolicyContainer = new UnityContainer();
AllowFredPolicyContainer
.AddNewExtension<Interception>()
.Configure<Interception>()
.SetDefaultInterceptorFor<AuthorizationTestTarget>(new TransparentProxyInterceptor())
.AddPolicy("allowFred")
.AddCallHandler<AuthorizationCallHandler>(
new InjectionConstructor(typeof(IAuthorizationProvider), "OnlyFredHasAccess", 0))
.AddMatchingRule(new AlwaysMatchingRule());
new UnityContainerConfigurator(AllowFredPolicyContainer).RegisterAll(authorizationConfiguration, securitySettings);
AllowJackPolicyContainer = new UnityContainer();
AllowJackPolicyContainer
.AddNewExtension<Interception>()
.Configure<Interception>()
.SetDefaultInterceptorFor<AuthorizationTestTarget>(new TransparentProxyInterceptor())
.AddPolicy("allowJack")
.AddCallHandler<AuthorizationCallHandler>(
new InjectionConstructor(typeof(IAuthorizationProvider), "OnlyJackHasAccess", 0))
.AddMatchingRule(new AlwaysMatchingRule());
new UnityContainerConfigurator(AllowJackPolicyContainer).RegisterAll(authorizationConfiguration, securitySettings);
AllowBasedOnTokensPolicyContainer = new UnityContainer();
AllowBasedOnTokensPolicyContainer
.AddNewExtension<Interception>()
.Configure<Interception>()
.SetDefaultInterceptorFor<AuthorizationTestTarget>(new TransparentProxyInterceptor())
.AddPolicy("tokens")
.AddCallHandler<AuthorizationCallHandler>(
new InjectionConstructor(typeof(IAuthorizationProvider), "{type}-{method}", 0))
.AddMatchingRule(new AlwaysMatchingRule());
new UnityContainerConfigurator(AllowBasedOnTokensPolicyContainer).RegisterAll(authorizationConfiguration, securitySettings);
}
public void TryToSaveWithNullOrEmptySectionNameThrows()
{
FileConfigurationSource source = new FileConfigurationSource(file, false);
source.Save(null, CreateInstrumentationSection());
}
/// <summary>
/// Returns a new <see cref="FileConfigurationSource"/> configured with the receiver's settings.
/// </summary>
/// <returns>A new configuration source.</returns>
protected internal override IConfigurationSource CreateSource()
{
IConfigurationSource createdObject = new FileConfigurationSource(FilePath);
return(createdObject);
}
/// <summary>
/// 初始化数据库
/// </summary>
private void InitDatabase()
{
IConfigurationSource configurationSource =
new FileConfigurationSource(string.Format("{0}{1}", AppDomain.CurrentDomain.BaseDirectory, "Database.config"));
DatabaseFactory.SetDatabaseProviderFactory(new DatabaseProviderFactory(configurationSource));
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Cedar.Core.SettingSource.ConfigurationFileSettingSource" /> class.
/// </summary>
/// <param name="filePath">The file path.</param>
public ConfigurationFileSettingSource(string filePath)
{
Guard.ArgumentNotNullOrEmpty(filePath, "filePath");
this.filePath = filePath;
ConfigurationSource = new FileConfigurationSource(filePath);
}
private static void LoadConfiguration()
{
var configurationSource = new FileConfigurationSource(ConfigurationTestHelper.ConfigurationFileName, false);
configurationSource.GetSection(LoggingSettings.SectionName);
}
public void TryToSaveWithConfigurationMultipleTimes()
{
string tempFile = CreateFile();
try
{
using (var source = new FileConfigurationSource(tempFile, false))
{
source.Add(InstrumentationConfigurationSection.SectionName, CreateInstrumentationSection());
ValidateConfiguration(tempFile);
source.Add(InstrumentationConfigurationSection.SectionName, CreateInstrumentationSection());
ValidateConfiguration(tempFile);
source.Add(InstrumentationConfigurationSection.SectionName, CreateInstrumentationSection());
ValidateConfiguration(tempFile);
}
}
finally
{
if (File.Exists(tempFile)) File.Delete(tempFile);
}
}
public void TryToSaveWithNullSectionThrows()
{
FileConfigurationSource source = new FileConfigurationSource(file, false);
source.Save(InstrumentationConfigurationSection.SectionName, null);
}
public void then_attributes_with_omitted_values_are_overridden()
{
FileConfigurationSource source = new FileConfigurationSource(TargetFile);
InstrumentationConfigurationSection instrumentationSettings = (InstrumentationConfigurationSection)source.GetSection(InstrumentationConfigurationSection.SectionName);
Assert.AreEqual("Overriden Application", instrumentationSettings.ApplicationInstanceName);
Assert.IsTrue(instrumentationSettings.EventLoggingEnabled);
Assert.IsTrue(instrumentationSettings.PerformanceCountersEnabled);
}
public override IConfigurationSource CreateSource()
{
IConfigurationSource createdObject = new FileConfigurationSource(FilePath);
return(createdObject);
}
private void InitializeCacheManager()
{
if (null == _cacheManager)
{
var fileSource = new FileConfigurationSource("SUT.PrintEngine.App.config");
var factory = new CacheManagerFactory(fileSource);
_cacheManager = factory.CreateDefault();
}
}
