public void RuleFromTypeAndMethodNameTest()
{
string typeDefinition = "Open.SPF.Core.Test.TestCustomRules, Open.SPF.Core.Test, Version=1.2.1.0, Culture=neutral, PublicKeyToken=b4313207536550be";
string methodName = "CustomRuleIsAlwaysAuthorized";
Type ruleType = Type.GetType(typeDefinition);
Assert.IsTrue(typeof(ICustomRuleContainer).IsAssignableFrom(ruleType));
ConstructorInfo constructorMethod = ruleType.GetConstructor(new Type[0]);
Assert.IsNotNull(constructorMethod);
ICustomRuleContainer uut; // = new TestCustomRules();
uut = (ICustomRuleContainer)constructorMethod.Invoke(new object[0]);
Assert.IsNotNull(uut);
Type[] methodSignature = new Type[] { typeof(IIdentity), typeof(IEnumerable <string>), typeof(object), typeof(Dictionary <string, object>) };
MethodInfo ruleMethodInfo = ruleType.GetMethod(methodName, methodSignature);
Assert.IsNotNull(ruleMethodInfo);
PermissionRules.IsAuthorizedMethod del = (PermissionRules.IsAuthorizedMethod)ruleMethodInfo.CreateDelegate(typeof(PermissionRules.IsAuthorizedMethod), uut);
Assert.IsNotNull(del);
Dictionary <string, object> contextPropertyBag = uut.PreparePropertiesForRule("CustomRuleIsAlwaysAuthorized", null);
bool?isAuthorized = del.Invoke(TestIdentity, TestRoles, null, contextPropertyBag);
Assert.IsTrue(isAuthorized.HasValue);
Assert.IsTrue(isAuthorized.Value);
}
public void ContextObjectTest()
{
string methodName = "CustomRuleAreEqualRule";
PermissionRules uut = new PermissionRules();
ICustomRuleContainer customContainer = new TestCustomRules();
PermissionRules.IsAuthorizedMethod del = uut.RuleDelegateFromMethodName(customContainer, methodName);
Assert.IsNotNull(del);
Dictionary <string, object> contextPropertyBag = customContainer.PreparePropertiesForRule(methodName, null);
contextPropertyBag.Add("ContextCompareObject", Guid.NewGuid());
// No context object is passed. Should return false
bool?isAuthorized = del.Invoke(PermissionRulesTests.TestIdentity, PermissionRulesTests.TestRoles, null, contextPropertyBag);
Assert.IsTrue(isAuthorized.HasValue);
Assert.IsFalse(isAuthorized.Value);
// A different context object is passed. Should return false
isAuthorized = del.Invoke(PermissionRulesTests.TestIdentity, PermissionRulesTests.TestRoles, Guid.NewGuid(), contextPropertyBag);
Assert.IsTrue(isAuthorized.HasValue);
Assert.IsFalse(isAuthorized.Value);
// The same context object is passed. Should return true
isAuthorized = del.Invoke(PermissionRulesTests.TestIdentity, PermissionRulesTests.TestRoles, contextPropertyBag["ContextCompareObject"], contextPropertyBag);
Assert.IsTrue(isAuthorized.HasValue);
Assert.IsTrue(isAuthorized.Value);
}
public PermissionRuleContext(string ruleName, string permissionName, object contextObject, Dictionary <string, object> propertyBag, PermissionRules.IsAuthorizedMethod ruleDelegate)
{
ContextId = Guid.NewGuid();
RuleName = ruleName;
PermissionName = permissionName;
ContextObject = contextObject;
PropertyBag = propertyBag ?? new Dictionary <string, object>();
RuleDelegate = ruleDelegate;
}
public void NeverAuthorizedRuleTest()
{
TestCustomRules uut = new TestCustomRules();
PermissionRules.IsAuthorizedMethod del = new PermissionRules.IsAuthorizedMethod(uut.CustomRuleIsNeverAuthorized);
Dictionary <string, object> contextPropertyBag = uut.PreparePropertiesForRule("CustomRuleIsNeverAuthorized", null);
bool?isAuthorized = del.Invoke(TestIdentity, TestRoles, null, contextPropertyBag);
Assert.IsTrue(isAuthorized.HasValue);
Assert.IsFalse(isAuthorized.Value);
}
public void RuleFromInvalidRuleTest()
{
ICustomRuleContainer testContainer = new TestCustomRules();
PermissionRules uut = new PermissionRules();
PermissionRules.IsAuthorizedMethod testRule = uut.RuleDelegateFromMethodName(testContainer, "BOGUS");
Assert.IsNull(testRule);
testRule = uut.RuleDelegateFromMethodName(testContainer, "CustomRuleIsNotValidRule");
Assert.IsNull(testRule);
testRule = uut.RuleDelegateFromMethodName(testContainer, "CustomRuleWrongSignatureRule");
Assert.IsNull(testRule);
}
public void InvalidPropertyBagTest()
{
string methodName = "CustomRuleAreEqualRule";
PermissionRules uut = new PermissionRules();
ICustomRuleContainer customContainer = new TestCustomRules();
PermissionRules.IsAuthorizedMethod del = uut.RuleDelegateFromMethodName(customContainer, methodName);
Assert.IsNotNull(del);
Dictionary <string, object> contextPropertyBag = customContainer.PreparePropertiesForRule(methodName, null);
// contextPropertyBag.Add("ContextCompareObject", Guid.NewGuid()); // don't pass in a ContextCompareObject
// No context compare object is passed. Should throw error
bool?isAuthorized = del.Invoke(PermissionRulesTests.TestIdentity, PermissionRulesTests.TestRoles, null, contextPropertyBag);
}
public void ParallelRulesTest()
{
List <Task <bool?> > ruleTasks = new List <Task <bool?> >();
TestCustomRules customRules = new TestCustomRules();
PermissionRules uut = new PermissionRules();
Open.Common.Configuration.CommonConfiguration test = new Common.Configuration.CommonConfiguration();
PermissionRules.IsAuthorizedMethod del1 = new PermissionRules.IsAuthorizedMethod(customRules.CustomRuleIsAlwaysAuthorized);
Dictionary <string, object> contextPropertyBag1 = customRules.PreparePropertiesForRule("CustomRuleIsAlwaysAuthorized", null);
PermissionRuleContext ruleState1 = new PermissionRuleContext("CustomRuleIsAlwaysAuthorized", "CanDoStuff", contextPropertyBag1, del1);
Task <bool?> task1 = uut.TaskFromPermissionRuleContext(ruleState1, PermissionRulesTests.TestIdentity, PermissionRulesTests.TestRoles);
PermissionRules.IsAuthorizedMethod del2 = new PermissionRules.IsAuthorizedMethod(customRules.CustomRuleIsNeverAuthorized);
Dictionary <string, object> contextPropertyBag2 = customRules.PreparePropertiesForRule("CustomRuleIsNeverAuthorized", null);
PermissionRuleContext ruleState2 = new PermissionRuleContext("CustomRuleIsNeverAuthorized", "MayNotDoThisStuff", contextPropertyBag2, del2);
Task <bool?> task2 = uut.TaskFromPermissionRuleContext(ruleState2, PermissionRulesTests.TestIdentity, PermissionRulesTests.TestRoles);
task1.Start();
ruleTasks.Add(task1);
task2.Start();
ruleTasks.Add(task2);
// It's almost pointless because both tasks have likely finished by this point, but it's worth excercising the proper code
Task.WaitAll(ruleTasks.ToArray());
bool wasAlwaysRuleFound = false;
bool wasNeverRuleFound = false;
foreach (Task <bool?> ruleTask in ruleTasks)
{
if ((Guid)ruleTask.AsyncState == ruleState1.ContextId)
{
Assert.IsTrue(ruleTask.Result.HasValue);
Assert.IsTrue(ruleTask.Result.Value);
wasAlwaysRuleFound = true;
}
else if ((Guid)ruleTask.AsyncState == ruleState2.ContextId)
{
Assert.IsTrue(ruleTask.Result.HasValue);
Assert.IsFalse(ruleTask.Result.Value);
wasNeverRuleFound = true;
}
}
Assert.IsTrue(wasAlwaysRuleFound && wasNeverRuleFound);
}
public void ParallelRulesTest()
{
List <Task <bool?> > ruleTasks = new List <Task <bool?> >();
TestCustomRules uut = new TestCustomRules();
PermissionRules.IsAuthorizedMethod del1 = new PermissionRules.IsAuthorizedMethod(uut.CustomRuleIsAlwaysAuthorized);
Dictionary <string, object> contextPropertyBag1 = uut.PreparePropertiesForRule("CustomRuleIsAlwaysAuthorized", null);
PermissionRules.IsAuthorizedMethod del2 = new PermissionRules.IsAuthorizedMethod(uut.CustomRuleIsNeverAuthorized);
Dictionary <string, object> contextPropertyBag2 = uut.PreparePropertiesForRule("CustomRuleIsNeverAuthorized", null);
Guid alwaysRuleGuid = Guid.NewGuid();
Task <bool?> task1 = new Task <bool?>(a => del1.Invoke(TestIdentity, TestRoles, null, contextPropertyBag1), alwaysRuleGuid);
task1.Start();
ruleTasks.Add(task1);
Guid neverRuleGuid = Guid.NewGuid();
Task <bool?> task2 = new Task <bool?>(a => del2.Invoke(TestIdentity, TestRoles, null, contextPropertyBag2), neverRuleGuid);
task2.Start();
ruleTasks.Add(task2);
// It's almost pointless because both tasks have likely finished by this point, but it's worth excercising the proper code
Task.WaitAll(ruleTasks.ToArray());
bool wasAlwaysRuleFound = false;
bool wasNeverRuleFound = false;
foreach (Task <bool?> ruleTask in ruleTasks)
{
if ((Guid)ruleTask.AsyncState == alwaysRuleGuid)
{
Assert.IsTrue(ruleTask.Result.HasValue);
Assert.IsTrue(ruleTask.Result.Value);
wasAlwaysRuleFound = true;
}
else if ((Guid)ruleTask.AsyncState == neverRuleGuid)
{
Assert.IsTrue(ruleTask.Result.HasValue);
Assert.IsFalse(ruleTask.Result.Value);
wasNeverRuleFound = true;
}
}
Assert.IsTrue(wasAlwaysRuleFound && wasNeverRuleFound);
}
public void CoreUserRoledRuleTest()
{
PermissionRules uut = new PermissionRules();
PermissionRules.IsAuthorizedMethod del = new PermissionRules.IsAuthorizedMethod(uut.IsUserRoleAuthorizedRule);
Dictionary <string, object> contextPropertyBag = uut.PrepareStateForRoleRule(TestRoles[0]);
bool?isAuthorized = del.Invoke(TestIdentity, TestRoles, null, contextPropertyBag);
Assert.IsTrue(isAuthorized.HasValue);
Assert.IsTrue(isAuthorized.Value);
contextPropertyBag = uut.PrepareStateForRoleRule("BOGUS");
isAuthorized = del.Invoke(TestIdentity, TestRoles, null, contextPropertyBag);
Assert.IsTrue(isAuthorized.HasValue);
Assert.IsFalse(isAuthorized.Value);
}
public void RuleFromTypeAndMethodNameTest()
{
string typeName = "Open.SPF.Core.Test.TestCustomRules, Open.SPF.Core.Test, Version=1.2.1, Culture=neutral, PublicKeyToken=b4313207536550be";
string methodName = "CustomRuleIsAlwaysAuthorized";
PermissionRules uut = new PermissionRules();
ICustomRuleContainer customContainer = uut.CustomRuleContainerFromTypeName(typeName);
Assert.IsNotNull(customContainer);
PermissionRules.IsAuthorizedMethod del = uut.RuleDelegateFromMethodName(customContainer, methodName);
Assert.IsNotNull(del);
string ruleName = uut.RuleNameFromMethodName(customContainer, methodName);
Assert.IsNotNull(ruleName);
Assert.AreEqual(methodName, ruleName);
Dictionary <string, object> contextPropertyBag = customContainer.PreparePropertiesForRule(ruleName, null);
bool?isAuthorized = del.Invoke(PermissionRulesTests.TestIdentity, PermissionRulesTests.TestRoles, null, contextPropertyBag);
Assert.IsTrue(isAuthorized.HasValue);
Assert.IsTrue(isAuthorized.Value);
}
public PermissionRuleContext(string ruleName, string permissionName, Dictionary <string, object> propertyBag, PermissionRules.IsAuthorizedMethod ruleDelegate)
: this(ruleName, permissionName, null, propertyBag, ruleDelegate)
{
}
public PermissionRuleContext(string ruleName, string permissionName, PermissionRules.IsAuthorizedMethod ruleDelegate)
: this(ruleName, permissionName, null, ruleDelegate)
{
}
