public void ShouldCreateCorrectMatchingRule()
{
ValidationFactory.SetDefaultConfigurationValidatorFactory(new ConfigurationValidatorFactory(new DictionaryConfigurationSource()));
PolicyData policyData = new PolicyData("Validate Parameters");
policyData.Handlers.Add(new ValidationCallHandlerData());
ParameterTypeMatchingRuleData matchingRuleData = GetParameterTypeMatchingRuleData();
policyData.MatchingRules.Add(matchingRuleData);
PolicyInjectionSettings settings = new PolicyInjectionSettings();
settings.Policies.Add(policyData);
DictionaryConfigurationSource configSource = new DictionaryConfigurationSource();
configSource.Add(PolicyInjectionSettings.SectionName, settings);
IUnityContainer container = new UnityContainer().AddNewExtension<Interception>();
settings.ConfigureContainer(container);
RuleDrivenPolicy policy = container.Resolve<RuleDrivenPolicy>("Validate Parameters");
List<IMatchingRule> rules = RuleCreationFixture.GetRules(policy);
Assert.IsNotNull(policy);
Assert.IsTrue(rules[0] is ParameterTypeMatchingRule);
ParameterTypeMatchingRule rule = (ParameterTypeMatchingRule)(rules[0]);
Assert.AreEqual(3, rule.ParameterMatches.Count());
for (int i = 0; i < matchingRuleData.Matches.Count; ++i)
{
AssertMatchDataEqual(
matchingRuleData.Matches[i],
rule.ParameterMatches.ElementAt(i),
"Mismatch at element {0}",
i);
}
}
public void AddTo(IConfigurationSource configurationSource)
{
var section = new PolicyInjectionSettings();
foreach(var builder in builders)
{
builder.AddTo(section);
}
configurationSource.Add(BlockSectionNames.PolicyInjection, section);
}
public void CanSerializeConfigurationFixture()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policy1 = new PolicyData(policy1Name);
PolicyData policy2 = new PolicyData(policy2Name);
settings.Policies.Add(policy1);
settings.Policies.Add(policy2);
CustomCallHandlerData handler1 = new CustomCallHandlerData(handler1Name, typeof(CallCountHandler));
handler1.SetAttributeValue("customHandlerAttribute", "customHandlerAttributeValue");
CustomMatchingRuleData customMatchingRule = new CustomMatchingRuleData(matchingRule1Name, typeof(TypeMatchingAssignmentRule));
customMatchingRule.SetAttributeValue("customMatchingRuleAttribute", "customMatchingRuleAttributeValue");
policy1.Handlers.Add(handler1);
policy1.MatchingRules.Add(customMatchingRule);
Dictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>();
sections.Add(PolicyInjectionSettings.SectionName, settings);
IConfigurationSource configurationSource = ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);
PolicyInjectionSettings deserializedSection = (PolicyInjectionSettings)configurationSource.GetSection(PolicyInjectionSettings.SectionName);
Assert.AreEqual(2, deserializedSection.Policies.Count);
PolicyData deserializedPolicy1 = deserializedSection.Policies.Get(0);
Assert.IsNotNull(deserializedPolicy1);
Assert.AreEqual(policy1Name, deserializedPolicy1.Name);
CallHandlerData deserializedHandler = deserializedPolicy1.Handlers.Get(0);
Assert.IsNotNull(deserializedHandler);
Assert.IsNotNull(deserializedHandler as CustomCallHandlerData);
Assert.AreEqual(handler1Name, deserializedHandler.Name);
Assert.AreEqual(typeof(CallCountHandler), deserializedHandler.Type);
Assert.AreEqual("customHandlerAttributeValue", (string)deserializedHandler.ElementInformation.Properties["customHandlerAttribute"].Value);
Assert.AreEqual(policy2Name, deserializedSection.Policies.Get(1).Name);
MatchingRuleData deserializedMatchingRule = deserializedPolicy1.MatchingRules.Get(0);
Assert.IsNotNull(deserializedMatchingRule as CustomMatchingRuleData);
Assert.AreEqual(matchingRule1Name, deserializedMatchingRule.Name);
Assert.AreEqual(typeof(TypeMatchingAssignmentRule), deserializedMatchingRule.Type);
Assert.AreEqual("customMatchingRuleAttributeValue", (string)deserializedMatchingRule.ElementInformation.Properties["customMatchingRuleAttribute"].Value);
}
public void CanCreatePolicyWithMethodSignatureMatchingRule()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
settings.Policies.Add(new PolicyData("Policy"));
settings.Policies.Get(0).MatchingRules.Add(new MethodSignatureMatchingRuleData("RuleName", "memberName"));
DictionaryConfigurationSource dictSource = new DictionaryConfigurationSource();
dictSource.Add(PolicyInjectionSettings.SectionName, settings);
settings.ConfigureContainer(container);
RuleDrivenPolicy policy = container.Resolve<RuleDrivenPolicy>("Policy");
List<IMatchingRule> rules = GetRules(policy);
Assert.IsNotNull(policy);
Assert.AreEqual("Policy", policy.Name);
Assert.AreEqual(1, rules.Count);
Assert.AreEqual(typeof(MethodSignatureMatchingRule), rules[0].GetType());
}
protected static MatchingRuleData SerializeAndDeserializeMatchingRule(MatchingRuleData typeMatchingRule)
{
PolicyData policy = new PolicyData("policy");
policy.MatchingRules.Add(typeMatchingRule);
PolicyInjectionSettings settings = new PolicyInjectionSettings();
settings.Policies.Add(policy);
Dictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>();
sections.Add(PolicyInjectionSettings.SectionName, settings);
IConfigurationSource configurationSource = ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);
PolicyInjectionSettings deserializedSection = configurationSource.GetSection(PolicyInjectionSettings.SectionName) as PolicyInjectionSettings;
Assert.IsNotNull(deserializedSection);
PolicyData deserializedPolicy = deserializedSection.Policies.Get(0);
Assert.IsNotNull(deserializedPolicy);
return deserializedPolicy.MatchingRules.Get(0);
}
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 static CallHandlerData SerializeAndDeserializeHandler(CallHandlerData handlerData)
{
PolicyData policy = new PolicyData("policy");
policy.Handlers.Add(handlerData);
PolicyInjectionSettings settings = new PolicyInjectionSettings();
settings.Policies.Add(policy);
Dictionary<string, ConfigurationSection> sections = new Dictionary<string, ConfigurationSection>();
sections.Add(PolicyInjectionSettings.SectionName, settings);
IConfigurationSource configurationSource =
ConfigurationTestHelper.SaveSectionsInFileAndReturnConfigurationSource(sections);
PolicyInjectionSettings deserializedSection =
configurationSource.GetSection(PolicyInjectionSettings.SectionName) as PolicyInjectionSettings;
Assert.IsNotNull(deserializedSection);
PolicyData deserializedPolicy = deserializedSection.Policies.Get(0);
Assert.IsNotNull(deserializedPolicy);
return deserializedPolicy.Handlers.Get(0);
}
public void TestCallHandlerCustomFactory()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policyData = new PolicyData("policy");
ExceptionCallHandlerData data = new ExceptionCallHandlerData("exceptionhandler", "Swallow Exceptions");
data.Order = 5;
policyData.Handlers.Add(data);
policyData.MatchingRules.Add(new CustomMatchingRuleData("matchesEverything", typeof(AlwaysMatchingRule)));
settings.Policies.Add(policyData);
ExceptionHandlingSettings ehabSettings = new ExceptionHandlingSettings();
ExceptionPolicyData swallowExceptions = new ExceptionPolicyData("Swallow Exceptions");
swallowExceptions.ExceptionTypes.Add(new ExceptionTypeData("Exception", typeof(Exception), PostHandlingAction.None));
ehabSettings.ExceptionPolicies.Add(swallowExceptions);
DictionaryConfigurationSource dictConfigurationSource = new DictionaryConfigurationSource();
dictConfigurationSource.Add(PolicyInjectionSettings.SectionName, settings);
IUnityContainer container = new UnityContainer().AddNewExtension<Interception>();
settings.ConfigureContainer(container, dictConfigurationSource);
new UnityContainerConfigurator(container).RegisterAll(dictConfigurationSource, ehabSettings);
InjectionFriendlyRuleDrivenPolicy policy = container.Resolve<InjectionFriendlyRuleDrivenPolicy>("policy");
ICallHandler handler
= (policy.GetHandlersFor(new MethodImplementationInfo(null, (MethodInfo)MethodBase.GetCurrentMethod()), container)).ElementAt(0);
Assert.IsNotNull(handler);
Assert.AreEqual(handler.Order, data.Order);
}
public void CanCreateExceptionHandlerFromConfiguration()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policyData = new PolicyData("policy");
policyData.Handlers.Add(new ExceptionCallHandlerData("exceptionhandler", "Swallow Exceptions"));
policyData.MatchingRules.Add(new CustomMatchingRuleData("matchesEverything", typeof(AlwaysMatchingRule)));
settings.Policies.Add(policyData);
ExceptionHandlingSettings ehabSettings = new ExceptionHandlingSettings();
ExceptionPolicyData swallowExceptions = new ExceptionPolicyData("Swallow Exceptions");
swallowExceptions.ExceptionTypes.Add(new ExceptionTypeData("Exception", typeof(Exception), PostHandlingAction.None));
ehabSettings.ExceptionPolicies.Add(swallowExceptions);
DictionaryConfigurationSource dictConfigurationSource = new DictionaryConfigurationSource();
dictConfigurationSource.Add(PolicyInjectionSettings.SectionName, settings);
dictConfigurationSource.Add(ExceptionHandlingSettings.SectionName, ehabSettings);
using (PolicyInjector injector = new PolicyInjector(dictConfigurationSource))
{
TargetType target = injector.Create<TargetType>();
target.WillThrowException();
}
}
public void CanCreateCategoriesFromConfiguration()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policyData = new PolicyData("Perfmon policy");
//policyData.MatchingRules.Add(new TagAttributeMatchingRuleData("Match By Tag", "Perfmon"));
PerformanceCounterCallHandlerData counterData = new PerformanceCounterCallHandlerData("{type}.{method}");
counterData.CategoryName = firstCategory;
policyData.Handlers.Add(counterData);
settings.Policies.Add(policyData);
DictionaryConfigurationSource configSource = new DictionaryConfigurationSource();
configSource.Add(PolicyInjectionSettings.SectionName, settings);
PerformanceCountersInstaller installer = new PerformanceCountersInstaller(configSource);
CommitInstall(installer);
Assert.IsTrue(PerformanceCounterCategory.Exists(firstCategory));
Assert.IsFalse(PerformanceCounterCategory.Exists(secondCategory));
}
public void Setup()
{
settings = new PolicyInjectionSettings();
settings.Policies.Add(new PolicyData("policy 1") { });
}
static PolicyInjectionSettings GetInjectionSettings()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policy = new PolicyData("Intercept DoSomething");
policy.MatchingRules.Add(new MemberNameMatchingRuleData("Match DoSomething", "DoSomething"));
PerformanceCounterCallHandlerData handlerData =
new PerformanceCounterCallHandlerData("Perfcounters");
handlerData.CategoryName = "Category";
handlerData.InstanceName = "Instance";
policy.Handlers.Add(handlerData);
settings.Policies.Add(policy);
return settings;
}
public void Setup()
{
settings = new PolicyInjectionSettings();
}
static InjectionFriendlyRuleDrivenPolicy CreatePolicySetContainingCallHandler(
ValidationCallHandlerData validationCallHandler,
IUnityContainer container)
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policyData = new PolicyData("policy");
policyData.MatchingRules.Add(new CustomMatchingRuleData("match everything", typeof(AlwaysMatchingRule)));
policyData.Handlers.Add(validationCallHandler);
settings.Policies.Add(policyData);
DictionaryConfigurationSource dictionaryConfigurationSource = new DictionaryConfigurationSource();
dictionaryConfigurationSource.Add(PolicyInjectionSettings.SectionName, settings);
settings.ConfigureContainer(container, dictionaryConfigurationSource);
return container.Resolve<InjectionFriendlyRuleDrivenPolicy>("policy");
}
public void Setup()
{
var policyData = new PolicyData("policy 1");
policyData.MatchingRules.Add(
new TypeMatchingRuleData("matching rule 1", typeof(object).AssemblyQualifiedName));
settings = new PolicyInjectionSettings();
settings.Policies.Add(policyData);
}
public void AssembledProperlyPerfCounterHandler()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policyData = new PolicyData("policy");
PerformanceCounterCallHandlerData data = new PerformanceCounterCallHandlerData("FooCallHandler", 2);
policyData.MatchingRules.Add(new CustomMatchingRuleData("match everything", typeof(AlwaysMatchingRule)));
policyData.Handlers.Add(data);
settings.Policies.Add(policyData);
DictionaryConfigurationSource dictConfigurationSource = new DictionaryConfigurationSource();
dictConfigurationSource.Add(PolicyInjectionSettings.SectionName, settings);
IUnityContainer container = new UnityContainer().AddNewExtension<Interception>();
settings.ConfigureContainer(container, dictConfigurationSource);
InjectionFriendlyRuleDrivenPolicy policy = container.Resolve<InjectionFriendlyRuleDrivenPolicy>("policy");
ICallHandler handler
= (policy.GetHandlersFor(GetMethodImpl(MethodBase.GetCurrentMethod()), container)).ElementAt(0);
Assert.IsNotNull(handler);
Assert.AreEqual(handler.Order, data.Order);
}
public void CanCreatePolicyWithCustomCallHandler()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
settings.Policies.Add(new PolicyData("Policy"));
settings.Policies.Get(0).MatchingRules.Add(new CustomMatchingRuleData("alwaysTrue", typeof(AlwaysMatchingRule)));
settings.Policies.Get(0).Handlers.Add(new CustomCallHandlerData("callCountHandler", typeof(CallCountHandler)));
DictionaryConfigurationSource dictSource = new DictionaryConfigurationSource();
dictSource.Add(PolicyInjectionSettings.SectionName, settings);
settings.ConfigureContainer(container);
RuleDrivenPolicy policy = container.Resolve<RuleDrivenPolicy>("Policy");
List<ICallHandler> handlers
= new List<ICallHandler>(policy.GetHandlersFor(MakeMethodImplementationInfo(MethodBase.GetCurrentMethod()), container));
Assert.IsNotNull(policy);
Assert.AreEqual("Policy", policy.Name);
Assert.AreEqual(1, handlers.Count);
Assert.AreEqual(typeof(CallCountHandler), handlers[0].GetType());
}
public void AddTo(PolicyInjectionSettings settings)
{
settings.Policies.Add(new PolicyData(policySetting.Name));
}
public void ConfiguresCustomCallHandlerAsSingleton()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
settings.Policies.Add(new PolicyData("Policy"));
settings.Policies.Get(0).MatchingRules.Add(new CustomMatchingRuleData("alwaysTrue", typeof(AlwaysMatchingRule)));
settings.Policies.Get(0).Handlers.Add(new CustomCallHandlerData("callCountHandler", typeof(CallCountHandler)));
DictionaryConfigurationSource dictSource = new DictionaryConfigurationSource();
dictSource.Add(PolicyInjectionSettings.SectionName, settings);
settings.ConfigureContainer(container);
RuleDrivenPolicy policy = container.Resolve<RuleDrivenPolicy>("Policy");
List<ICallHandler> handlers1
= new List<ICallHandler>(policy.GetHandlersFor(MakeMethodImplementationInfo(MethodBase.GetCurrentMethod()), container));
List<ICallHandler> handlers2
= new List<ICallHandler>(policy.GetHandlersFor(MakeMethodImplementationInfo(MethodBase.GetCurrentMethod()), container));
CollectionAssert.AreEquivalent(handlers1, handlers2);
}
public void CreateAuthorizationCallHandlerFromConfiguration()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
PolicyData policyData = new PolicyData("policy");
AuthorizationCallHandlerData data = new AuthorizationCallHandlerData("foo", 2);
policyData.MatchingRules.Add(new CustomMatchingRuleData("matchesEverything", typeof(AlwaysMatchingRule)));
policyData.Handlers.Add(data);
settings.Policies.Add(policyData);
using (var configSource = new FileConfigurationSource("Authorization.config", false))
{
IUnityContainer container = new UnityContainer().AddNewExtension<Interception>();
settings.ConfigureContainer(container, configSource);
new UnityContainerConfigurator(container)
.RegisterAll(
configSource,
(ITypeRegistrationsProvider)configSource.GetSection(SecuritySettings.SectionName));
InjectionFriendlyRuleDrivenPolicy policy = container.Resolve<InjectionFriendlyRuleDrivenPolicy>("policy");
ICallHandler handler =
(policy.GetHandlersFor(new MethodImplementationInfo(null, (MethodInfo)MethodBase.GetCurrentMethod()), container)).ElementAt(0);
Assert.IsNotNull(handler);
Assert.AreEqual(handler.Order, data.Order);
//Assert.AreSame(authorizationProvider, ((AuthorizationCallHandler)handler).AutorizationProvider); // TODO this test only checked for provider name, so it didn't fail even though the configuration source supplied didn't have the settings required to build it
}
}
IConfigurationSource CreateConfigurationSource(string globalCallHandlerName)
{
PolicyInjectionSettings injectionSettings = new PolicyInjectionSettings();
PolicyData policyData = new PolicyData();
CustomCallHandlerData customCallHandlerData = new CustomCallHandlerData("globalCountHandler", typeof(GlobalCountCallHandler));
customCallHandlerData.Attributes.Add("callhandler", globalCallHandlerName);
policyData.Handlers.Add(customCallHandlerData);
policyData.MatchingRules.Add(new CustomMatchingRuleData("alwaystrue", typeof(AlwaysMatchingRule)));
injectionSettings.Policies.Add(policyData);
DictionaryConfigurationSource configSource = new DictionaryConfigurationSource();
configSource.Add(PolicyInjectionSettings.SectionName, injectionSettings);
return configSource;
}
public void Setup()
{
var policyData = new PolicyData("policy 1");
policyData.MatchingRules.Add(
new TypeMatchingRuleData("matching rule 1", typeof(object).AssemblyQualifiedName));
policyData.Handlers.Add(
new CustomCallHandlerData("handler 1", typeof(CallCountHandler).AssemblyQualifiedName));
settings = new PolicyInjectionSettings();
settings.Policies.Add(policyData);
}
public void CanCreatePolicyWithCustomAttributeMatchingRule()
{
PolicyInjectionSettings settings = new PolicyInjectionSettings();
settings.Policies.Add(new PolicyData("Policy"));
settings.Policies.Get(0).MatchingRules
.Add(new CustomAttributeMatchingRuleData("alwaysTrue", typeof(TagAttribute), true));
DictionaryConfigurationSource dictSource = new DictionaryConfigurationSource();
dictSource.Add(PolicyInjectionSettings.SectionName, settings);
settings.ConfigureContainer(container);
RuleDrivenPolicy policy = container.Resolve<RuleDrivenPolicy>("Policy");
List<IMatchingRule> rules = GetRules(policy);
Assert.IsNotNull(policy);
Assert.AreEqual("Policy", policy.Name);
Assert.AreEqual(1, rules.Count);
Assert.AreEqual(typeof(CustomAttributeMatchingRule), rules[0].GetType());
}
public void TestInitialize()
{
this.source = new DictionaryConfigurationSource();
var settings = new PolicyInjectionSettings();
settings.Policies.Add(new PolicyData("policy 1") { });
this.source.Add(PolicyInjectionSettings.SectionName, settings);
}