public void GivenUserHasRoles_WhenIAuthorize_ThenRolesAreLoaded()
{
HttpContext context = new HttpContext(new HttpRequest("", "http://tempuri.org", ""), new HttpResponse(new StringWriter()));
HttpContext.Current = context;
AuthenticateAndAuthorizeAttribute target = new AuthenticateAndAuthorizeAttribute();
ControllerContext controllerContext = new ControllerContext(new HttpContextWrapper(context), new RouteData(), new TestController());
ActionDescriptor action = new ReflectedActionDescriptor(typeof(TestController).GetMethod("Index"), "Index", new ReflectedControllerDescriptor(typeof(TestController)));
AuthorizationContext authContext = new AuthorizationContext(controllerContext, action);
context.User = new System.Security.Claims.ClaimsPrincipal(new System.Security.Claims.ClaimsIdentity[]
{
new System.Security.Claims.ClaimsIdentity(new System.Security.Claims.Claim[]
{
new System.Security.Claims.Claim(System.Security.Claims.ClaimTypes.NameIdentifier, "Bob")
}, "Test")
});
controllerContext.RouteData.Values.Add("action", "bob");
controllerContext.RouteData.Values.Add("controller", "fred");
target.OnAuthorization(authContext);
Assert.IsInstanceOfType(context.User, typeof(EducationSecurityPrincipal));
User user = ((EducationSecurityPrincipal)context.User).Identity.User;
Assert.IsNotNull(user.UserRoles.FirstOrDefault().Role);
Assert.AreEqual(SecurityRoles.DataAdmin, user.UserRoles.First().Role.Name);
}
/// <summary>
/// Gets the action descriptor and caches it
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="controllerDescriptor"></param>
/// <param name="actionName"></param>
/// <returns></returns>
protected ReflectedActionDescriptor GetActionDescriptor(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
var found = _descriptorCache.GetOrAdd(
controllerDescriptor.UniqueId,
s => new ReflectedActionDescriptor(
controllerContext.Controller.GetType().GetMethods()
.First(x => x.Name == actionName &&
x.GetCustomAttributes(typeof(NonActionAttribute), false).Any() == false),
actionName,
controllerDescriptor));
//check if the action name matches, it won't if the user has changed the action name in umbraco, if this occurs we need to refresh the cache
if (!found.ActionName.InvariantEquals(actionName))
{
var newDescriptor = new ReflectedActionDescriptor(
controllerContext.Controller.GetType().GetMethods()
.First(x => x.Name == actionName &&
x.GetCustomAttributes(typeof (NonActionAttribute), false).Any() == false),
actionName,
controllerDescriptor);
_descriptorCache.TryUpdate(controllerDescriptor.UniqueId, newDescriptor, found);
found = newDescriptor;
}
return found;
}
public void When_getting_controller_attributes_then_builds_up_instance()
{
using (var container = new UnityContainer())
{
// Arrange
var someInstance = new SomeClass();
container.RegisterInstance<ISomeInterface>(someInstance);
container.RegisterType<TestFilterAttribute>(new InjectionProperty("Some"));
var context = new ControllerContext { Controller = new ControllerWithTypeAttribute() };
var controllerDescriptor = new ReflectedControllerDescriptor(context.Controller.GetType());
var action = context.Controller.GetType().GetMethod("MyActionMethod");
var actionDescriptor = new ReflectedActionDescriptor(action, "MyActionMethod", controllerDescriptor);
var provider = new UnityFilterAttributeFilterProvider(container);
// Act
Filter filter = provider.GetFilters(context, actionDescriptor).Single();
// Assert
TestFilterAttribute attrib = filter.Instance as TestFilterAttribute;
Assert.IsNotNull(attrib);
Assert.AreEqual(FilterScope.Controller, filter.Scope);
Assert.AreEqual(1234, filter.Order);
Assert.AreSame(someInstance, attrib.Some);
}
}
public FilterRegisterItem(Type controllerType, ReflectedActionDescriptor actionDescriptor, Type[] filterTypes)
{
ControllerType = controllerType;
ActionDescriptor = actionDescriptor;
_actionParameterDescriptors = ActionDescriptor.GetParameters();
FilterTypes = filterTypes;
Filters = () => FilterTypes.Select(f => Activator.CreateInstance(f) as FilterAttribute);
}
public void FixtureSetUp()
{
_baseControllerContext = new ControllerContext {Controller = new TestController()};
_baseMethodInfo = TestController.GetAction1MethodInfo<TestController>();
_actionName = _baseMethodInfo.Name;
_controllerDescriptor = new Mock<ControllerDescriptor>().Object;
_reflectedActionDescriptor = new ReflectedActionDescriptor(_baseMethodInfo, _actionName, _controllerDescriptor);
}
public void can_match_castle_proxied_controller()
{
var controllerTypeConstraint = new ControllerTypeConstraint<TestController>();
var proxyGenerator = new ProxyGenerator();
var interfaceProxyWithTarget = proxyGenerator.CreateClassProxy<TestController>();
var controllerType = interfaceProxyWithTarget.GetType();
var actionDescriptor = new ReflectedActionDescriptor(controllerType.GetMethod("ReturnViewResult"), "ReturnViewResult", new ReflectedControllerDescriptor(controllerType));
controllerTypeConstraint
.IsSatisfiedBy(new ControllerFilterSelector(null, actionDescriptor.ControllerDescriptor, EmptyActionDescriptor.Instance))
.ShouldBeTrue();
}
public override IAsyncResult BeginExecute(ControllerContext controllerContext, IDictionary<string, object> parameters, AsyncCallback callback, object state)
{
Task result = new ReflectedActionDescriptor(this.MethodInfo, this.ActionName, this.ControllerDescriptor).Execute(controllerContext, parameters) as Task;
if (result == null)
{
throw new InvalidOperationException(string.Format("Method {0} should have returned a Task!", (object)this.MethodInfo));
}
else
{
if (callback != null)
result.ContinueWith((Action<Task>)(_ => callback((IAsyncResult)result)));
return (IAsyncResult)result;
}
}
/// <summary>
/// Начинает выполнение асинхронной операции, описанной в action'e
/// </summary>
/// <param name="controllerContext">текущий контекст контроллера</param>
/// <param name="parameters">параметры action'а</param>
/// <param name="callback">делегат, который вызывается после завершения
/// асинхронной операции</param>
/// <param name="state">дополнительное состояние</param>
/// <returns>возвращает асинхронную операцию в виде <see cref="IAsyncResult" /></returns>
public override IAsyncResult BeginExecute(
ControllerContext controllerContext, IDictionary<string, object> parameters, AsyncCallback callback, object state)
{
var rad = new ReflectedActionDescriptor(_methodInfo, ActionName, ControllerDescriptor);
var result = rad.Execute(controllerContext, parameters) as Task;
if (result == null)
{
throw new InvalidOperationException(
String.Format("Метод {0} должен был вернуть Task!", _methodInfo));
}
if (callback != null)
{
result.ContinueWith(_ => callback(result));
}
return result;
}
public void can_resolve_through_registry()
{
var controllerTypeConstraint = new ControllerTypeConstraint<TestController>();
var method = typeof(TestController).GetMethods().First(x => x.Name.Equals("ReturnNull") && x.GetParameters().Count() == 0);
var actionDescriptor = new ReflectedActionDescriptor(method, "ReturnNull", new ReflectedControllerDescriptor(typeof(TestController)));
var registry = new ActionFilterRegistry(new FluentMvcObjectFactory());
registry.Add(new ControllerActionRegistryItem(typeof(TestFilter), controllerTypeConstraint, actionDescriptor, actionDescriptor.ControllerDescriptor));
var proxyGenerator = new ProxyGenerator();
var interfaceProxyWithTarget = proxyGenerator.CreateClassProxy<TestController>();
var controllerType = interfaceProxyWithTarget.GetType();
var methodInfos = controllerType.GetMethods();
var proxyActionDescriptor = new ReflectedActionDescriptor(methodInfos.First(x => x.Name.Equals("ReturnNull") && x.GetParameters().Count() == 0), "ReturnNull", new ReflectedControllerDescriptor(controllerType));
registry
.CanSatisfy(new ControllerActionFilterSelector(null, proxyActionDescriptor, proxyActionDescriptor.ControllerDescriptor))
.ShouldBeTrue();
}
public void IndexTest()
{
var errorMsg = "访问被拒绝，请通过微信客户端访问！";
var filter = new WeixinInternalRequestAttribute(errorMsg);
{
//模拟微信内置浏览器打开
Init(weixinUserAgent);//初始化
ActionDescriptor ad = new ReflectedActionDescriptor(target.GetType().GetMethod("Index"), "Index",
new ReflectedAsyncControllerDescriptor(target.GetType()));
ActionExecutingContext aec = new ActionExecutingContext(target.ControllerContext, ad,
new Dictionary<string, object>());
filter.OnActionExecuting(aec);
Assert.IsNull(aec.Result);
//下面的测试和UserAgent无关，只要Index可以被调用，都会有同样的结果
ContentResult actual = target.Index();
Assert.IsTrue(actual.Content.Contains("访问正常"));
}
{
//模拟外部浏览器打开
Init(outsideUserAgent);//初始化
ActionDescriptor ad = new ReflectedActionDescriptor(target.GetType().GetMethod("Index"), "Index",
new ReflectedAsyncControllerDescriptor(target.GetType()));
ActionExecutingContext aec = new ActionExecutingContext(target.ControllerContext, ad,
new Dictionary<string, object>());
filter.OnActionExecuting(aec);
Assert.IsNotNull(aec.Result);
Assert.IsTrue(aec.Result is ContentResult);
Assert.AreEqual(errorMsg, (aec.Result as ContentResult).Content);
}
}
private ActionDescriptor[] LazilyFetchCanonicalActionsCollection()
{
return(DescriptorUtil.LazilyFetchOrCreateDescriptors(
cacheLocation: ref _canonicalActionsCache,
initializer: (ReflectedControllerDescriptor state) => state.GetAllActionMethodsFromSelector(),
converter: (MethodInfo methodInfo, ReflectedControllerDescriptor state) => ReflectedActionDescriptor.TryCreateDescriptor(methodInfo, methodInfo.Name, state),
state: this));
}
protected ReflectedTaskAsyncActionDescriptor(ReflectedActionDescriptor actionDescriptor)
{
_actionDescriptor = actionDescriptor;
}
internal static ReflectedActionDescriptor TryCreateDescriptor(MethodInfo methodInfo, string name, ControllerDescriptor controllerDescriptor) {
ReflectedActionDescriptor descriptor = new ReflectedActionDescriptor(methodInfo, name, controllerDescriptor, false /* validateMethod */);
string failedMessage = VerifyActionMethodIsCallable(methodInfo);
return (failedMessage == null) ? descriptor : null;
}
private static ActionDescriptor CreateActionDescriptor()
{
ControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(typeof(SampleController));
var method = typeof(SampleController).GetMethod("Execute");
ActionDescriptor actionDescriptor = new ReflectedActionDescriptor(method, "Execute", controllerDescriptor);
return actionDescriptor;
}
public DescribedMvcActionInfo(ActionDescriptor actionDescr, ControllerInfo controller)
: base(controller)
{
this.actionDescr = actionDescr;
this.reflectedActionDescr = actionDescr as ReflectedActionDescriptor;
}
public MyReflectedActionDescriptor(ReflectedActionDescriptor actionDescriptor)
: base(actionDescriptor.MethodInfo, actionDescriptor.ActionName, actionDescriptor.ControllerDescriptor)
{
this.ActionExecutor = new ActionExecutor(actionDescriptor.MethodInfo);
}
private static bool IsMethodDecoratedWithAliasingAttribute(ReflectedActionDescriptor actionDesc)
{
bool inherit = true;
return actionDesc.MethodInfo.IsDefined(ApiControllerActionSelector_old.ActionNameSelectorType, inherit);
}
protected override ActionDescriptor FindAction(ControllerContext cc, ControllerDescriptor cd,
string actionName)
{
if (defAct != null)
{
var ad = new ReflectedActionDescriptor(defAct, defAct.Name, cd);
return ad;
}
else
{
var c = cc.Controller;
var mi = c.GetType()
.GetMethod(actionName,
BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.Public |
BindingFlags.IgnoreCase);
if (mi != null)
{
var ad = new ReflectedActionDescriptor(mi, actionName, cd);
return ad;
}
}
return base.FindAction(cc, cd, actionName);
}
