private static InjectionPolicy CreatePolicy(IUnityContainer container, IMatchingRule[] rules) { InjectionPolicy p = new RuleDrivenPolicy(rules, new string[] { "handler1", "handler2", "handler3" }); return(p); }
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); ExceptionPolicyData swallowExceptions = new ExceptionPolicyData("Swallow Exceptions"); swallowExceptions.ExceptionTypes.Add(new ExceptionTypeData("Exception", typeof(Exception), PostHandlingAction.None)); DictionaryConfigurationSource dictConfigurationSource = new DictionaryConfigurationSource(); IUnityContainer container = new UnityContainer().AddNewExtension <Interception>(); settings.ConfigureContainer(container); container.RegisterInstance("Swallow Exceptions", swallowExceptions.BuildExceptionPolicy()); RuleDrivenPolicy policy = container.Resolve <RuleDrivenPolicy>("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 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); RuleDrivenPolicy policy = container.Resolve <RuleDrivenPolicy>("policy"); ICallHandler handler = (policy.GetHandlersFor(GetMethodImpl(MethodBase.GetCurrentMethod()), container)).ElementAt(0); Assert.IsNotNull(handler); Assert.AreEqual(handler.Order, data.Order); }
public void TestInitialize() { IConfigurationSource authorizationConfiguration = new FileConfigurationSource("Authorization.config"); RuleDrivenPolicy allowFredPolicy = new RuleDrivenPolicy("allowFred"); allowFredPolicy.Handlers.Add(new AuthorizationCallHandler("RuleProvider", "OnlyFredHasAccess", authorizationConfiguration)); allowFredPolicy.RuleSet.Add(new AlwaysMatchingRule()); AllowFredPolicySet = new PolicySet(allowFredPolicy); RuleDrivenPolicy allowJackPolicy = new RuleDrivenPolicy("allowJack"); allowJackPolicy.Handlers.Add(new AuthorizationCallHandler(string.Empty, "OnlyJackHasAccess", authorizationConfiguration)); allowJackPolicy.RuleSet.Add(new AlwaysMatchingRule()); AllowJackPolicySet = new PolicySet(allowJackPolicy); RuleDrivenPolicy tokenBasedPolicy = new RuleDrivenPolicy("tokens"); tokenBasedPolicy.RuleSet.Add(new AlwaysMatchingRule()); tokenBasedPolicy.Handlers.Add( new AuthorizationCallHandler(string.Empty, "{type}-{method}", authorizationConfiguration)); AllowBasedOnTokensPolicySet = new PolicySet(tokenBasedPolicy); }
public void ShouldCreateCorrectMatchingRule() { 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); PolicySetFactory factory = new PolicySetFactory(configSource); PolicySet policies = factory.Create(); Policy policy = policies[1]; Assert.IsTrue(policy is RuleDrivenPolicy); RuleDrivenPolicy validateRule = (RuleDrivenPolicy)policy; Assert.IsTrue(validateRule.RuleSet[0] is ParameterTypeMatchingRule); ParameterTypeMatchingRule rule = (ParameterTypeMatchingRule)(validateRule.RuleSet[0]); Assert.AreEqual(3, rule.ParameterMatches.Count); for (int i = 0; i < matchingRuleData.Matches.Count; ++i) { AssertMatchDataEqual(matchingRuleData.Matches[i], rule.ParameterMatches[i], "Mismatch at element {0}", i); } }
PolicySet GetPolicySet(ICallHandler handler) { RuleDrivenPolicy magicPolicy = new RuleDrivenPolicy(); magicPolicy.RuleSet.Add(new TagAttributeMatchingRule("Magic")); magicPolicy.Handlers.Add(handler); return new PolicySet(magicPolicy); }
public void ShouldInitializeToEmpty() { RuleDrivenPolicy p = new RuleDrivenPolicy("Empty"); Assert.AreEqual("Empty", p.Name); Assert.AreEqual(0, p.RuleSet.Count); Assert.AreEqual(0, p.Handlers.Count); }
public static List <IMatchingRule> GetRules(RuleDrivenPolicy policy) { return((List <IMatchingRule>) typeof(Microsoft.Practices.Unity.InterceptionExtension.RuleDrivenPolicy) .GetField( "ruleSet", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance) .GetValue(policy)); }
private PolicySet GetPolicySet(ICallHandler handler) { RuleDrivenPolicy magicPolicy = new RuleDrivenPolicy(); magicPolicy.RuleSet.Add(new TagAttributeMatchingRule("Magic")); magicPolicy.Handlers.Add(handler); return(new PolicySet(magicPolicy)); }
private void AddNoopPolicy(PolicyInjector factory, params IMatchingRule[] rules) { RuleDrivenPolicy p = new RuleDrivenPolicy("Noop"); p.RuleSet.AddRange(rules); p.Handlers.Add(new NoopCallHandler()); factory.Policies.Add(p); }
private PolicySet GetCachingPolicies() { RuleDrivenPolicy cachePolicy = new RuleDrivenPolicy("Caching"); cachePolicy.RuleSet.Add(new TypeMatchingRule(typeof(CachingTarget))); cachePolicy.Handlers.Add(new CachingCallHandler()); return(new PolicySet(cachePolicy)); }
private void AddExceptionPolicy(PolicyInjector factory, string exceptionPolicyName, params IMatchingRule[] rules) { RuleDrivenPolicy exceptionPolicy = new RuleDrivenPolicy(); exceptionPolicy.RuleSet.AddRange(rules); exceptionPolicy.Handlers.Add(new ExceptionCallHandler(exceptionPolicyName)); factory.Policies.Add(exceptionPolicy); }
private PolicySet GetPerfMonPolicies() { RuleDrivenPolicy policy = new RuleDrivenPolicy("Monitor all methods"); policy.RuleSet.Add(new TypeMatchingRule(typeof(MonitorTarget))); callHandler = new PerformanceCounterCallHandler(TestCategoryName, TestInstanceName); policy.Handlers.Add(callHandler); return(new PolicySet(policy)); }
PolicySet GetPolicies(IUnityContainer container) { RuleDrivenPolicy p = new RuleDrivenPolicy( "PipelineTestPolicy", new IMatchingRule[] { new AlwaysMatchingRule() }, new string[] { "call count", "rewrite" }); return(new PolicySet(p)); }
private RuleDrivenPolicy GetPolicyThatMatchesInterface() { RuleDrivenPolicy policy = new RuleDrivenPolicy("Matches IDal"); TypeMatchingAssignmentRule rule = new TypeMatchingAssignmentRule(typeof(IDal)); countHandler = new CallCountHandler(); policy.RuleSet.Add(rule); policy.Handlers.Add(countHandler); return(policy); }
PolicySet GetPolicies(IUnityContainer container) { RuleDrivenPolicy p = new RuleDrivenPolicy( "PipelineTestPolicy", new IMatchingRule[] { new AlwaysMatchingRule() }, new string[] { "call count", "rewrite" }); return new PolicySet(p); }
private PolicySet GetPolicies() { RuleDrivenPolicy p = new RuleDrivenPolicy("PipelineTestPolicy"); p.RuleSet.Add(new AlwaysMatchingRule()); callCountHandler = new CallCountHandler(); returnHandler = new StringReturnRewriteHandler("REWRITE"); p.Handlers.Add(callCountHandler); p.Handlers.Add(returnHandler); return(new PolicySet(p)); }
private void AddOverloadsPolicy(PolicyInjector factory) { RuleDrivenPolicy policy = new RuleDrivenPolicy("NullStringPolicy"); TagAttributeMatchingRule tagRule = new TagAttributeMatchingRule("NullString"); policy.RuleSet.Add(tagRule); policy.Handlers.Add(new MakeReturnNullHandler()); factory.Policies.Add(policy); }
private RuleDrivenPolicy GetShortcutPolicy( ) { RuleDrivenPolicy typeMatchPolicy = new RuleDrivenPolicy("ShortcutPolicy"); TypeMatchingAssignmentRule typeRule = new TypeMatchingAssignmentRule(typeof(MockDal)); typeMatchPolicy.RuleSet.Add(typeRule); ShortcuttingHandler handler = new ShortcuttingHandler("shortcut"); typeMatchPolicy.Handlers.Add(handler); return(typeMatchPolicy); }
private RuleDrivenPolicy GetCallCountingPolicy() { RuleDrivenPolicy typeMatchPolicy = new RuleDrivenPolicy("DALPolicy"); NamespaceMatchingRule nsMatchRule = new NamespaceMatchingRule( "Microsoft.Practices.EnterpriseLibrary.PolicyInjection.Tests.ObjectsUnderTest"); typeMatchPolicy.RuleSet.Add(nsMatchRule); countHandler = new CallCountHandler(); typeMatchPolicy.Handlers.Add(countHandler); return(typeMatchPolicy); }
private void AddPropertiesPolicy(PolicyInjector factory) { RuleDrivenPolicy policy = new RuleDrivenPolicy("Intercept balance policy"); MemberNameMatchingRule rule = new MemberNameMatchingRule("get_Balance"); policy.RuleSet.Add(rule); countHandler = new CallCountHandler(); policy.Handlers.Add(countHandler); factory.Policies.Add(policy); }
public void HandlersOrderedProperlyUsingRelativeAndAbsoluteOrder() { RuleDrivenPolicy policy = new RuleDrivenPolicy("MatchesInterfacePolicy", new IMatchingRule[] { new TypeMatchingRule("ITwo") }, new string[] { "Handler1", "Handler2", "Handler3", "Handler4", "Handler5", "Handler6" }); ICallHandler handler1 = new CallCountHandler(); handler1.Order = 0; ICallHandler handler2 = new CallCountHandler(); handler2.Order = 3; ICallHandler handler3 = new CallCountHandler(); handler3.Order = 3; ICallHandler handler4 = new CallCountHandler(); handler4.Order = 2; ICallHandler handler5 = new CallCountHandler(); handler5.Order = 4; ICallHandler handler6 = new CallCountHandler(); handler6.Order = 1; container .RegisterInstance <ICallHandler>("Handler1", handler1) .RegisterInstance <ICallHandler>("Handler2", handler2) .RegisterInstance <ICallHandler>("Handler3", handler3) .RegisterInstance <ICallHandler>("Handler4", handler4) .RegisterInstance <ICallHandler>("Handler5", handler5) .RegisterInstance <ICallHandler>("Handler6", handler6); PolicySet policies = new PolicySet(policy); MethodImplementationInfo twoInfo = new MethodImplementationInfo( typeof(ITwo).GetMethod("Two"), typeof(TwoType).GetMethod("Two")); List <ICallHandler> handlers = new List <ICallHandler>(policies.GetHandlersFor(twoInfo, container)); Assert.AreEqual(handler6, handlers[0]); Assert.AreEqual(handler4, handlers[1]); Assert.AreEqual(handler2, handlers[2]); Assert.AreEqual(handler3, handlers[3]); Assert.AreEqual(handler5, handlers[4]); Assert.AreEqual(handler1, handlers[5]); }
public void CanCreateValidationCallHandlerThroughFactory() { ValidationCallHandlerData validationCallHandler = new ValidationCallHandlerData("validationHandler"); IUnityContainer container = new UnityContainer().AddNewExtension <Interception>(); RuleDrivenPolicy policy = CreatePolicySetContainingCallHandler(validationCallHandler, container); ICallHandler runtimeHandler = (policy.GetHandlersFor(new MethodImplementationInfo(null, (MethodInfo)MethodBase.GetCurrentMethod()), container)).ElementAt(0); Assert.IsNotNull(runtimeHandler); }
public void ShouldMatchForMethodWhenTagIsOnInterfaceViaPolicy() { RuleDrivenPolicy policy = new RuleDrivenPolicy("Count tagged calls"); policy.RuleSet.Add(new TagAttributeMatchingRule("Tag on interface", true)); policy.Handlers.Add(new CallCountHandler()); MethodInfo createMethod = typeof(DaoImpl).GetMethod("Create"); List <ICallHandler> handlers = new List <ICallHandler>(policy.GetHandlersFor(createMethod)); Assert.AreEqual(1, handlers.Count); Assert.IsTrue(handlers[0] is CallCountHandler); }
public void ShouldHaveNoHandlersWhenPolicyDoesntMatch() { RuleDrivenPolicy p = new RuleDrivenPolicy("NoRules"); ICallHandler[] handlers = { new Handler1(), new Handler2(), new Handler3() }; Array.ForEach(handlers, delegate(ICallHandler handler) { p.Handlers.Add(handler); }); MethodBase thisMember = this.GetType().GetMethod("ShouldHaveNoHandlersWhenPolicyDoesntMatch"); List <ICallHandler> memberHandlers = new List <ICallHandler>(p.GetHandlersFor(thisMember)); Assert.AreEqual(0, memberHandlers.Count); }
public void ShouldNotDuplicateHandlersWhenCreatingViaInterface() { DictionaryConfigurationSource configSource = new DictionaryConfigurationSource(); RuleDrivenPolicy policy = new RuleDrivenPolicy("MatchesInterfacePolicy"); policy.RuleSet.Add(new TypeMatchingRule("ITwo")); policy.Handlers.Add(new ValidationCallHandler(string.Empty, SpecificationSource.Both)); policy.Handlers.Add(new CallCountHandler()); PolicySet policies = new PolicySet(policy); List <ICallHandler> handlers = new List <ICallHandler>(policies.GetHandlersFor(typeof(Bar).GetMethod("Two"))); Assert.AreEqual(2, handlers.Count); }
private PolicySet GetMultiplePolicySet() { RuleDrivenPolicy typeMatchPolicy = new RuleDrivenPolicy("MatchesType"); typeMatchPolicy.RuleSet.Add(new TypeMatchingRule(typeof(MatchesByType))); typeMatchPolicy.Handlers.Add(new Handler1()); RuleDrivenPolicy nameMatchPolicy = new RuleDrivenPolicy("MatchesName"); nameMatchPolicy.RuleSet.Add(new MemberNameMatchingRule("NameMatch")); nameMatchPolicy.Handlers.Add(new Handler2()); return(new PolicySet(typeMatchPolicy, nameMatchPolicy)); }
public void ShouldOnlyGetHandlersOnceIfPolicyMatchesBothClassAndInterface() { RuleDrivenPolicy p = new RuleDrivenPolicy(); ICallHandler callHandler = new CallCountHandler(); MemberNameMatchingRule nameRule = new MemberNameMatchingRule("MyMethod"); p.RuleSet.Add(nameRule); p.Handlers.Add(callHandler); MethodInfo myMethod = typeof(MyFooClass).GetMethod("MyMethod"); List <ICallHandler> handlers = new List <ICallHandler>(p.GetHandlersFor(myMethod)); Assert.AreEqual(1, handlers.Count); Assert.AreSame(callHandler, handlers[0]); }
private PolicySet GetLoggingPolicies() { RuleDrivenPolicy p = new RuleDrivenPolicy("Logging"); p.RuleSet.Add(new TypeMatchingRule("LoggingTarget")); callHandler = new LogCallHandler(log); callHandler.LogBeforeCall = callHandler.LogAfterCall = true; callHandler.BeforeMessage = beforeMessage; callHandler.AfterMessage = afterMessage; callHandler.Categories.Add("General"); callHandler.Categories.Add("PIAB"); p.Handlers.Add(callHandler); return(new PolicySet(p)); }
public void ShouldBeAbleToMatchPropertyGet() { RuleDrivenPolicy p = new RuleDrivenPolicy("Property get"); p.RuleSet.Add(new MemberNameMatchingRule("get_Balance")); ICallHandler callHandler = new CallCountHandler(); p.Handlers.Add(callHandler); PropertyInfo balanceProperty = typeof(MockDal).GetProperty("Balance"); MethodBase getMethod = balanceProperty.GetGetMethod(); List <ICallHandler> handlers = new List <ICallHandler>(p.GetHandlersFor(getMethod)); Assert.AreEqual(1, handlers.Count); Assert.AreSame(callHandler, handlers[0]); }
public void ShouldPreserveHandlerOrder() { RuleDrivenPolicy p = new RuleDrivenPolicy("OrderedHandlers"); ICallHandler h1 = new Handler1(); ICallHandler h2 = new Handler2(); ICallHandler h3 = new Handler3(); p.Handlers.Add(h2); p.Handlers.Add(h1); p.Handlers.Add(h3); Assert.AreEqual(3, p.Handlers.Count); Assert.AreSame(h2, p.Handlers[0]); Assert.AreSame(h1, p.Handlers[1]); Assert.AreSame(h3, p.Handlers[2]); }
private PolicySet GetMultiplePolicySet() { container .RegisterInstance <ICallHandler>("Handler1", new Handler1()) .RegisterInstance <ICallHandler>("Handler2", new Handler2()); RuleDrivenPolicy typeMatchPolicy = new RuleDrivenPolicy("MatchesType", new IMatchingRule[] { new TypeMatchingRule(typeof(MatchesByType)) }, new string[] { "Handler1" }); RuleDrivenPolicy nameMatchPolicy = new RuleDrivenPolicy("MatchesName", new IMatchingRule[] { new MemberNameMatchingRule("NameMatch") }, new string[] { "Handler2" }); return(new PolicySet(typeMatchPolicy, nameMatchPolicy)); }
PolicySet GetPolicies() { PolicySet policies = new PolicySet(); RuleDrivenPolicy noParamsPolicy = new RuleDrivenPolicy( "noParamsPolicy", new IMatchingRule[] { new MatchByNameRule("MethodWithNoParameters") }, new string[] { "Handler1" }); container.RegisterInstance<ICallHandler>("Handler1", new SignatureCheckingHandler(new Type[] { })); policies.Add(noParamsPolicy); RuleDrivenPolicy simpleInputsPolicy = new RuleDrivenPolicy( "simpleInputsPolicy", new IMatchingRule[] { new MatchByNameRule("MethodWithSimpleInputs") }, new string[] { "Handler2" }); container.RegisterInstance<ICallHandler>( "Handler2", new SignatureCheckingHandler(new Type[] { typeof(int), typeof(string) })); policies.Add(simpleInputsPolicy); RuleDrivenPolicy outParamsPolicy = new RuleDrivenPolicy( "outParamsPolicy", new IMatchingRule[] { new MatchByNameRule("MethodWithOutParams") }, new string[] { "Handler3" }); container.RegisterInstance<ICallHandler>( "Handler3", new SignatureCheckingHandler(new Type[] { typeof(int).MakeByRefType(), typeof(string).MakeByRefType() })); policies.Add(outParamsPolicy); RuleDrivenPolicy mixedParamsPolicy = new RuleDrivenPolicy( "mixedParamsPolicy", new IMatchingRule[] { new MatchByNameRule("MethodWithInOutByrefParams") }, new string[] { "Handler4" }); container.RegisterInstance<ICallHandler>( "Handler4", new SignatureCheckingHandler( new Type[] { typeof(int), typeof(string).MakeByRefType(), typeof(float).MakeByRefType(), typeof(decimal) })); policies.Add(mixedParamsPolicy); RuleDrivenPolicy varargsParamsPolicy = new RuleDrivenPolicy( "varargsParamsPolicy", new IMatchingRule[] { new MatchByNameRule("MethodWithVarArgs") }, new string[] { "Handler5" }); container.RegisterInstance<ICallHandler>( "Handler5", new SignatureCheckingHandler(new Type[] { typeof(int), typeof(string).MakeArrayType() })); policies.Add(varargsParamsPolicy); return policies; }
PolicySet GetPolicies() { RuleDrivenPolicy doubleInputPolicy = new RuleDrivenPolicy( "Double your inputs", new IMatchingRule[] { new MemberNameMatchingRule("DoSomething") }, new string[] { "Handler1" }); container.RegisterInstance<ICallHandler>("Handler1", new DoubleInputHandler()); RuleDrivenPolicy tripleOutputPolicy = new RuleDrivenPolicy( "Triple an output parameter", new IMatchingRule[] { new MemberNameMatchingRule(new[] { "DoSomethingElse", "DoSomethingElseWithRef" }) }, new string[] { "Handler2" }); container.RegisterInstance<ICallHandler>("Handler2", new TripleOutputHandler()); return new PolicySet(doubleInputPolicy, tripleOutputPolicy); }