public static ContextUtil getInstance(string serverPath)
{
if (serverPath == null)
return instance;
if (instance == null)
instance = new ContextUtil(serverPath);
return instance;
}
public void BindSimpleCollection_SubBinderDoesNotExist()
{
// Arrange
CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
ModelBindingContext bindingContext = new ModelBindingContext
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
ModelName = "someName",
ValueProvider = new SimpleHttpValueProvider()
};
HttpActionContext context = ContextUtil.CreateActionContext();
context.ControllerContext.Configuration.ServiceResolver.SetService(typeof(ModelBinderProvider), null); // completely remove from resolution?
// Act
List <int> boundCollection = CollectionModelBinder <int> .BindSimpleCollection(context, bindingContext, new int[1], culture);
// Assert
Assert.Equal(new[] { 0 }, boundCollection.ToArray());
Assert.Empty(bindingContext.ValidationNode.ChildNodes);
}
public void MultipleValidationErrorsOnSameMemberReported()
{
// Arrange
ModelMetadataProvider metadataProvider = new CachedDataAnnotationsModelMetadataProvider();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
object model = new Address()
{
Street = "Microsoft Way"
};
// Act
Assert.DoesNotThrow(() =>
new DefaultBodyModelValidator().Validate(model, typeof(Address), metadataProvider, actionContext, string.Empty)
);
// Assert
Assert.Contains("Street", actionContext.ModelState.Keys);
ModelState streetState = actionContext.ModelState["Street"];
Assert.Equal(2, streetState.Errors.Count);
}
public void GetMetadataForProperties_WithBindAttribute()
{
// Arrange
string[] expectedPropertyNames = new[] { "FirstName", "LastName" };
HttpActionContext actionContext = ContextUtil.CreateActionContext();
ModelBindingContext bindingContext = new ModelBindingContext
{
ModelMetadata = GetMetadataForType(typeof(PersonWithBindExclusion))
};
TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();
// Act
IEnumerable <ModelMetadata> propertyMetadatas = testableBinder.GetMetadataForPropertiesPublic(actionContext, bindingContext);
string[] returnedPropertyNames = propertyMetadatas.Select(o => o.PropertyName).ToArray();
// Assert
Assert.Equal(expectedPropertyNames, returnedPropertyNames);
}
public Task ExecuteAuthorizationFilterAsync_IfContinuationTaskWasCanceled_ReturnsCanceledTask()
{
// Arrange
HttpActionContext context = ContextUtil.CreateActionContext();
Mock <AuthorizationFilterAttribute> filterMock = new Mock <AuthorizationFilterAttribute>()
{
CallBase = true,
};
var filter = (IAuthorizationFilter)filterMock.Object;
// Act & Assert
return(Assert.ThrowsAsync <TaskCanceledException>(
() =>
filter.ExecuteAuthorizationFilterAsync(
context,
CancellationToken.None,
() => TaskHelpers.Canceled <HttpResponseMessage>()
)
));
}
public void ExecuteActionFilterAsync_IfOnActionExecutedDoesNotChangeResult_ReturnsSameResult()
{
// Arrange
HttpActionContext context = ContextUtil.CreateActionContext();
Mock <ActionFilterAttribute> filterMock = new Mock <ActionFilterAttribute>();
var filter = (IActionFilter)filterMock.Object;
HttpResponseMessage response = new HttpResponseMessage();
filterMock.Setup(f => f.OnActionExecuted(It.IsAny <HttpActionExecutedContext>())).Callback <HttpActionExecutedContext>(ec =>
{
ec.Response = ec.Response;
});
// Act
var result = filter.ExecuteActionFilterAsync(context, CancellationToken.None, () => TaskHelpers.FromResult(response));
// Assert
result.WaitUntilCompleted();
Assert.True(result.IsCompleted);
Assert.Same(response, result.Result);
}
public void ValidationErrorsNotAddedOnInvalidFields()
{
// Arrange
ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
object model = new Address()
{
Street = "Microsoft Way"
};
actionContext.ModelState.AddModelError("Street", "error");
// Act
new DefaultBodyModelValidator().Validate(model, typeof(Address), metadataProvider, actionContext, string.Empty);
// Assert
Assert.Contains("Street", actionContext.ModelState.Keys);
ModelState streetState = actionContext.ModelState["Street"];
Assert.Equal(1, streetState.Errors.Count);
}
public void ExecuteActionFilterAsync_IfOnActionExecutedThrowsException_ReturnsFaultedTask()
{
// Arrange
HttpActionContext context = ContextUtil.CreateActionContext();
Mock <ActionFilterAttribute> filterMock = new Mock <ActionFilterAttribute>();
var filter = (IActionFilter)filterMock.Object;
Exception exception = new Exception("{AC32AD02-36A7-45E5-8955-76A4E3B461C6}");
filterMock.Setup(f => f.OnActionExecuted(It.IsAny <HttpActionExecutedContext>())).Callback <HttpActionExecutedContext>(ec =>
{
throw exception;
});
// Act
var result = filter.ExecuteActionFilterAsync(context, CancellationToken.None, () => TaskHelpers.FromResult(new HttpResponseMessage()));
// Assert
result.WaitUntilCompleted();
Assert.True(result.IsFaulted);
Assert.Same(exception, result.Exception.InnerException);
}
public void ExecuteActionFilterAsync_IfOnActionExecutedDoesHandleExceptionFromContinuation_ReturnsSuccessfulTask()
{
// Arrange
HttpActionContext context = ContextUtil.CreateActionContext();
Mock <ActionFilterAttribute> filterMock = new Mock <ActionFilterAttribute>();
var filter = (IActionFilter)filterMock.Object;
HttpResponseMessage newResponse = new HttpResponseMessage();
filterMock.Setup(f => f.OnActionExecuted(It.IsAny <HttpActionExecutedContext>())).Callback <HttpActionExecutedContext>(ec =>
{
ec.Response = newResponse;
});
// Act
var result = filter.ExecuteActionFilterAsync(context, CancellationToken.None, () => TaskHelpers.FromError <HttpResponseMessage>(new Exception("{ED525C8E-7165-4207-B3F6-4AB095739017}")));
// Assert
result.WaitUntilCompleted();
Assert.True(result.IsCompleted);
Assert.Same(newResponse, result.Result);
}
public void ExecuteActionFilterAsync_IfOnActionExecutedDoesNotHandleExceptionFromContinuation_ReturnsFaultedTask()
{
// Arrange
HttpActionContext context = ContextUtil.CreateActionContext();
Mock <ActionFilterAttribute> filterMock = new Mock <ActionFilterAttribute>();
var filter = (IActionFilter)filterMock.Object;
Exception exception = new Exception("{1EC330A2-33D0-4892-9335-2D833849D54E}");
filterMock.Setup(f => f.OnActionExecuted(It.IsAny <HttpActionExecutedContext>())).Callback <HttpActionExecutedContext>(ec =>
{
ec.Response = null;
});
// Act
var result = filter.ExecuteActionFilterAsync(context, CancellationToken.None, () => TaskHelpers.FromError <HttpResponseMessage>(exception));
// Assert
result.WaitUntilCompleted();
Assert.True(result.IsFaulted);
Assert.Same(exception, result.Exception.InnerException);
}
public void Validate_SkipsValidationIfHandlerCancels()
{
// Arrange
List <string> log = new List <string>();
LoggingValidatableObject model = new LoggingValidatableObject(log);
ModelMetadata modelMetadata = GetModelMetadata(model);
ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey");
node.Validating += (sender, e) =>
{
log.Add("In OnValidating()");
e.Cancel = true;
};
node.Validated += (sender, e) => log.Add("In OnValidated()");
// Act
node.Validate(ContextUtil.CreateActionContext());
// Assert
Assert.Equal(new[] { "In OnValidating()" }, log.ToArray());
}
public void SetProperty_SettingNonNullableValueTypeToNull_RequiredValidatorNotPresent_RegistersValidationCallback()
{
// Arrange
HttpActionContext context = ContextUtil.CreateActionContext();
ModelBindingContext bindingContext = new ModelBindingContext
{
ModelMetadata = GetMetadataForObject(new Person()),
};
ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(
o => o.PropertyName == "DateOfBirth"
);
ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo");
ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(
null /* model */
,
validationNode
);
ModelValidator requiredValidator = context
.GetValidators(propertyMetadata)
.Where(v => v.IsRequired)
.FirstOrDefault();
TestableMutableObjectModelBinder testableBinder =
new TestableMutableObjectModelBinder();
// Act
testableBinder.SetPropertyPublic(
context,
bindingContext,
propertyMetadata,
dtoResult,
requiredValidator
);
// Assert
Assert.True(context.ModelState.IsValid);
validationNode.Validate(context, bindingContext.ValidationNode);
Assert.False(context.ModelState.IsValid);
}
public void InvokeActionWithActionFilters_ChainsFiltersInOrderFollowedByInnerActionContinuation()
{
// Arrange
HttpActionContext actionContextInstance = ContextUtil.CreateActionContext();
List <string> log = new List <string>();
Mock <IActionFilter> globalFilterMock = CreateActionFilterMock((ctx, ct, continuation) =>
{
log.Add("globalFilter");
return(continuation());
});
Mock <IActionFilter> actionFilterMock = CreateActionFilterMock((ctx, ct, continuation) =>
{
log.Add("actionFilter");
return(continuation());
});
Func <Task <HttpResponseMessage> > innerAction = () => Task <HttpResponseMessage> .Factory.StartNew(() =>
{
log.Add("innerAction");
return(null);
});
var filters = new IActionFilter[] {
globalFilterMock.Object,
actionFilterMock.Object,
};
// Act
var result = ActionFilterResult.InvokeActionWithActionFilters(actionContextInstance,
CancellationToken.None, filters, innerAction);
// Assert
Assert.NotNull(result);
var resultTask = result();
Assert.NotNull(resultTask);
resultTask.WaitUntilCompleted();
Assert.Equal(new[] { "globalFilter", "actionFilter", "innerAction" }, log.ToArray());
globalFilterMock.Verify();
actionFilterMock.Verify();
}
public void Validate_SkipsRemainingValidationIfModelStateIsInvalid()
{
// Because a property validator fails, the model validator shouldn't run
// Arrange
List <string> log = new List <string>();
LoggingValidatableObject model = new LoggingValidatableObject(log);
ModelMetadata modelMetadata = GetModelMetadata(model);
ModelMetadata childMetadata = new EmptyModelMetadataProvider().GetMetadataForProperty(
() => model,
model.GetType(),
"InvalidStringProperty"
);
ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey");
node.ChildNodes.Add(
new ModelValidationNode(childMetadata, "theKey.InvalidStringProperty")
);
node.Validating += (sender, e) => log.Add("In OnValidating()");
node.Validated += (sender, e) => log.Add("In OnValidated()");
HttpActionContext context = ContextUtil.CreateActionContext();
// Act
node.Validate(context);
// Assert
Assert.Equal(
new[]
{
"In OnValidating()",
"In IValidatableObject.Validate()",
"In OnValidated()"
},
log.ToArray()
);
Assert.Equal(
"Sample error message",
context.ModelState["theKey.InvalidStringProperty"].Errors[0].ErrorMessage
);
}
public void Validate_Ordering()
{
// Proper order of invocation:
// 1. OnValidating()
// 2. Child validators
// 3. This validator
// 4. OnValidated()
// Arrange
List <string> log = new List <string>();
LoggingValidatableObject model = new LoggingValidatableObject(log);
ModelMetadata modelMetadata = GetModelMetadata(model);
ModelMetadata childMetadata = new EmptyModelMetadataProvider().GetMetadataForProperty(
() => model,
model.GetType(),
"ValidStringProperty"
);
ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey");
node.Validating += (sender, e) => log.Add("In OnValidating()");
node.Validated += (sender, e) => log.Add("In OnValidated()");
node.ChildNodes.Add(
new ModelValidationNode(childMetadata, "theKey.ValidStringProperty")
);
// Act
node.Validate(ContextUtil.CreateActionContext());
// Assert
Assert.Equal(
new[]
{
"In OnValidating()",
"In LoggingValidatonAttribute.IsValid()",
"In IValidatableObject.Validate()",
"In OnValidated()"
},
log.ToArray()
);
}
public void ExecuteAsync_Invokes_Inner_And_Traces()
{
// Arrange
HttpResponseMessage response = new HttpResponseMessage();
Mock <ApiController> mockController = new Mock <ApiController>()
{
CallBase = true
};
mockController.Setup(b => b.ExecuteAsync(It.IsAny <HttpControllerContext>(), It.IsAny <CancellationToken>())).Returns(TaskHelpers.FromResult <HttpResponseMessage>(response));
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(mockController.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin
},
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info)
{
Kind = TraceKind.End
}
};
// Act
HttpResponseMessage actualResponse = ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None).Result;
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(response, actualResponse);
}
public void ExpectedValidationErrorsRaised(
object model,
Type type,
Dictionary <string, string> expectedErrors
)
{
// Arrange
ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
HttpActionContext actionContext = ContextUtil.CreateActionContext();
// Act
Assert.DoesNotThrow(
() =>
new DefaultBodyModelValidator().Validate(
model,
type,
metadataProvider,
actionContext,
string.Empty
)
);
// Assert
Dictionary <string, string> actualErrors = new Dictionary <string, string>();
foreach (KeyValuePair <string, ModelState> keyStatePair in actionContext.ModelState)
{
foreach (ModelError error in keyStatePair.Value.Errors)
{
actualErrors.Add(keyStatePair.Key, error.ErrorMessage);
}
}
Assert.Equal(expectedErrors.Count, actualErrors.Count);
foreach (KeyValuePair <string, string> keyErrorPair in expectedErrors)
{
Assert.Contains(keyErrorPair.Key, actualErrors.Keys);
Assert.Equal(keyErrorPair.Value, actualErrors[keyErrorPair.Key]);
}
}
public HttpActionBindingTracerTest()
{
_mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
_mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
_mockActionDescriptor
.Setup(a => a.GetParameters())
.Returns(new Collection <HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
_mockParameterDescriptor = new Mock <HttpParameterDescriptor>()
{
CallBase = true
};
_mockParameterBinding = new Mock <HttpParameterBinding>(_mockParameterDescriptor.Object)
{
CallBase = true
};
_actionBinding = new HttpActionBinding(
_mockActionDescriptor.Object,
new HttpParameterBinding[] { _mockParameterBinding.Object }
);
_controllerDescriptor = new HttpControllerDescriptor(
new HttpConfiguration(),
"controller",
typeof(ApiController)
);
_controllerContext = ContextUtil.CreateControllerContext(
request: new HttpRequestMessage()
);
_controllerContext.ControllerDescriptor = _controllerDescriptor;
_actionContext = ContextUtil.CreateActionContext(
_controllerContext,
actionDescriptor: _mockActionDescriptor.Object
);
}
public void SetProperty_PropertyIsSettable_CallsSetter()
{
// Arrange
Person model = new Person();
HttpActionContext context = ContextUtil.CreateActionContext();
ModelBindingContext bindingContext = new ModelBindingContext
{
ModelMetadata = GetMetadataForObject(model)
};
ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(
o => o.PropertyName == "DateOfBirth"
);
ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo");
ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(
new DateTime(2001, 1, 1),
validationNode
);
ModelValidator requiredValidator = context
.GetValidators(propertyMetadata)
.Where(v => v.IsRequired)
.FirstOrDefault();
TestableMutableObjectModelBinder testableBinder =
new TestableMutableObjectModelBinder();
// Act
testableBinder.SetPropertyPublic(
context,
bindingContext,
propertyMetadata,
dtoResult,
requiredValidator
);
// Assert
validationNode.Validate(context);
Assert.True(context.ModelState.IsValid);
Assert.Equal(new DateTime(2001, 1, 1), model.DateOfBirth);
}
public void ExecuteAsync_IsCancelled_And_Traces_When_Inner_IsCancelled()
{
// Arrange
Mock <ApiController> mockController = new Mock <ApiController>()
{
CallBase = true
};
mockController.Setup(b => b.ExecuteAsync(It.IsAny <HttpControllerContext>(), It.IsAny <CancellationToken>())).Returns(TaskHelpers.Canceled <HttpResponseMessage>());
HttpRequestMessage request = new HttpRequestMessage();
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: request);
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin
},
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Warn)
{
Kind = TraceKind.End
}
};
// Act
Task task = ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None);
Exception thrown = Assert.Throws <TaskCanceledException>(() => task.Wait());
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public void ExecuteExceptionFilterAsync_Traces()
{
// Arrange
HttpRequestMessage request = new HttpRequestMessage();
HttpResponseMessage response = new HttpResponseMessage();
Mock <ExceptionFilterAttribute> mockAttr = new Mock <ExceptionFilterAttribute>()
{
CallBase = true
};
Mock <HttpActionDescriptor> mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection <HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
HttpActionExecutedContext actionExecutedContext = ContextUtil.GetActionExecutedContext(request, response);
TestTraceWriter traceWriter = new TestTraceWriter();
ExceptionFilterAttributeTracer tracer = new ExceptionFilterAttributeTracer(mockAttr.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin, Operation = "OnException"
},
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info)
{
Kind = TraceKind.End, Operation = "OnException"
},
};
// Act
Task task = ((IExceptionFilter)tracer).ExecuteExceptionFilterAsync(actionExecutedContext, CancellationToken.None);
task.Wait();
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public async Task TestConstructor_OnActionExecutingAsync_ResourceIdDoesNotExist()
{
var exceptionCaught = false;
var id = 1;
var actionArgument = "id";
var permissionModel = new PermissionModel
{
Id = Permission.ViewProgram.Id,
Name = Permission.ViewProgram.Value
};
var user = GetTestUser();
var warningMessage = string.Empty;
userProvider.Setup(x => x.GetCurrentUser()).Returns(user);
resourceService.Setup(x => x.GetResourceTypeId(It.IsAny <string>())).Returns(1);
resourceService.Setup(x => x.GetResourceByForeignResourceIdAsync(It.IsAny <int>(), It.IsAny <int>())).ReturnsAsync(default(ForeignResourceCache));
permissionService.Setup(x => x.HasPermission(It.IsAny <int>(), It.IsAny <int?>(), It.IsAny <int>(), It.IsAny <List <IPermission> >())).Returns(true);
permissionService.Setup(x => x.GetPermissionByNameAsync(It.IsAny <string>())).ReturnsAsync(permissionModel);
userProvider.Setup(x => x.IsUserValidAsync(It.IsAny <IWebApiUser>())).ReturnsAsync(true);
var attribute = new ResourceAuthorizeAttribute(permissionModel.Name, ResourceType.Program.Value, actionArgument);
try
{
var actionContext = ContextUtil.CreateActionContext();
actionContext.RequestContext.Principal = Thread.CurrentPrincipal;
actionContext.ActionArguments.Add(actionArgument, id);
var cts = new CancellationTokenSource();
await attribute.OnActionExecutingAsync(actionContext, cts.Token);
}
catch (HttpResponseException e)
{
exceptionCaught = true;
Assert.AreEqual(HttpStatusCode.Forbidden, e.Response.StatusCode);
}
Assert.IsTrue(exceptionCaught);
Assert.AreEqual(AuthorizationResult.ResourceDoesNotExist, attribute.GetAuthorizationResult());
//make sure we fall into checking permissions
userProvider.Verify(x => x.GetPermissionsAsync(It.IsAny <IWebApiUser>()), Times.Once());
}
public void ExecuteBindingAsync_Traces_And_Invokes_Inner_ReadAsync()
{
// Arrange
Mock <HttpParameterDescriptor> mockParamDescriptor = new Mock <HttpParameterDescriptor>()
{
CallBase = true
};
mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
FormatterParameterBinding binding = new FormatterParameterBinding(mockParamDescriptor.Object, new MediaTypeFormatterCollection(), null);
TestTraceWriter traceWriter = new TestTraceWriter();
FormatterParameterBindingTracer tracer = new FormatterParameterBindingTracer(binding, traceWriter);
HttpActionContext actionContext = ContextUtil.CreateActionContext();
actionContext.Request.Content = new StringContent("true");
actionContext.Request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
ModelMetadataProvider metadataProvider = new EmptyModelMetadataProvider();
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin, Operation = "ExecuteBindingAsync"
},
new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info)
{
Kind = TraceKind.End, Operation = "ExecuteBindingAsync"
}
};
// Act
Task task = tracer.ExecuteBindingAsync(metadataProvider, actionContext, CancellationToken.None);
task.Wait();
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Equal("True", actionContext.ActionArguments["paramName"]);
}
public async Task TestConstructor_OnActionExecutingAsync_ResourceTypeIsNotKnown()
{
var id = 1;
var foreignResourceCache = new ForeignResourceCache(0, id, 0, null, null, null);
var actionArgument = "id";
var permissionModel = new PermissionModel
{
Id = Permission.ViewProgram.Id,
Name = Permission.ViewProgram.Value
};
var resourceType = "idontexist";
var user = GetTestUser();
userProvider.Setup(x => x.GetCurrentUser()).Returns(user);
resourceService.Setup(x => x.GetResourceTypeId(It.IsAny <string>())).Returns(default(int?));
resourceService.Setup(x => x.GetResourceByForeignResourceIdAsync(It.IsAny <int>(), It.IsAny <int>())).ReturnsAsync(foreignResourceCache);
permissionService.Setup(x => x.HasPermission(It.IsAny <int>(), It.IsAny <int?>(), It.IsAny <int>(), It.IsAny <List <IPermission> >())).Returns(true);
permissionService.Setup(x => x.GetPermissionByNameAsync(It.IsAny <string>())).ReturnsAsync(permissionModel);
userProvider.Setup(x => x.IsUserValidAsync(It.IsAny <IWebApiUser>())).ReturnsAsync(true);
var attribute = new ResourceAuthorizeAttribute(permissionModel.Name, resourceType, actionArgument);
var actionContext = ContextUtil.CreateActionContext();
actionContext.RequestContext.Principal = Thread.CurrentPrincipal;
actionContext.ActionArguments.Add(actionArgument, id);
var cts = new CancellationTokenSource();
var exceptionCaught = false;
try
{
await attribute.OnActionExecutingAsync(actionContext, cts.Token);
}
catch (NotSupportedException e)
{
exceptionCaught = true;
Assert.AreEqual(String.Format("The resource type name [{0}] does not have a matching resource id in CAM.", resourceType), e.Message);
}
Assert.IsTrue(exceptionCaught);
}
public async Task ExecuteExceptionFilterAsync_Faults_And_Traces_When_Inner_Faults()
{
// Arrange
HttpRequestMessage request = new HttpRequestMessage();
HttpResponseMessage response = new HttpResponseMessage();
Mock <IExceptionFilter> mockFilter = new Mock <IExceptionFilter>()
{
CallBase = true
};
InvalidOperationException exception = new InvalidOperationException("test");
TaskCompletionSource <object> tcs = new TaskCompletionSource <object>(null);
tcs.TrySetException(exception);
mockFilter.Setup(a => a.ExecuteExceptionFilterAsync(It.IsAny <HttpActionExecutedContext>(), It.IsAny <CancellationToken>())).Returns(tcs.Task);
HttpActionExecutedContext actionExecutedContext = ContextUtil.GetActionExecutedContext(request, response);
TestTraceWriter traceWriter = new TestTraceWriter();
ExceptionFilterTracer tracer = new ExceptionFilterTracer(mockFilter.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin, Operation = "ExecuteExceptionFilterAsync"
},
new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Error)
{
Kind = TraceKind.End, Operation = "ExecuteExceptionFilterAsync"
}
};
// Act
Task task = ((IExceptionFilter)tracer).ExecuteExceptionFilterAsync(actionExecutedContext, CancellationToken.None);
// Assert
Exception thrown = await Assert.ThrowsAsync <InvalidOperationException>(() => task);
Assert.Same(exception, thrown);
Assert.Same(exception, traceWriter.Traces[1].Exception);
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
public void ExecuteAsync_ChainsFiltersInOrderFollowedByInnerActionContinuation()
{
// Arrange
HttpActionContext actionContextInstance = ContextUtil.CreateActionContext();
List <string> log = new List <string>();
Mock <IAuthorizationFilter> globalFilterMock = CreateAuthorizationFilterMock((ctx, ct, continuation) =>
{
log.Add("globalFilter");
return(continuation());
});
Mock <IAuthorizationFilter> actionFilterMock = CreateAuthorizationFilterMock((ctx, ct, continuation) =>
{
log.Add("actionFilter");
return(continuation());
});
Mock <IHttpActionResult> innerResultMock = new Mock <IHttpActionResult>();
innerResultMock.Setup(r => r.ExecuteAsync(It.IsAny <CancellationToken>())).Returns(() =>
{
log.Add("innerAction");
return(Task.FromResult <HttpResponseMessage>(null));
});
IHttpActionResult innerResult = innerResultMock.Object;
var filters = new IAuthorizationFilter[] {
globalFilterMock.Object,
actionFilterMock.Object,
};
IHttpActionResult authorizationFilter = new AuthorizationFilterResult(actionContextInstance, filters,
innerResult);
// Act
Task <HttpResponseMessage> result = authorizationFilter.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(result);
result.WaitUntilCompleted();
Assert.Equal(new[] { "globalFilter", "actionFilter", "innerAction" }, log.ToArray());
globalFilterMock.Verify();
actionFilterMock.Verify();
}
public void BindModel_MissingKey_ReturnsFalse()
{
// Arrange
KeyValuePairModelBinder <int, string> binder = new KeyValuePairModelBinder <int, string>();
ModelBindingContext bindingContext = new ModelBindingContext
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(KeyValuePair <int, string>)),
ModelName = "someName",
ValueProvider = new SimpleHttpValueProvider()
};
HttpActionContext context = ContextUtil.CreateActionContext();
context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), new SimpleModelBinderProvider(typeof(KeyValuePair <int, string>), binder));
// Act
bool retVal = binder.BindModel(context, bindingContext);
// Assert
Assert.False(retVal);
Assert.Null(bindingContext.Model);
Assert.Empty(bindingContext.ValidationNode.ChildNodes);
}
public async Task ExecuteActionFilterAsync_IfContinuationSucceeded_InvokesOnActionExecutedAsSuccess()
{
// Arrange
HttpActionContext context = ContextUtil.CreateActionContext();
Mock <ActionFilterAttribute> filterMock = new Mock <ActionFilterAttribute>()
{
CallBase = true,
};
var filter = (IActionFilter)filterMock.Object;
HttpResponseMessage response = new HttpResponseMessage();
// Act
await filter.ExecuteActionFilterAsync(context, CancellationToken.None, () => Task.FromResult(response));
// Assert
filterMock.Verify(f => f.OnActionExecuted(It.Is <HttpActionExecutedContext>(ec =>
Object.ReferenceEquals(ec.Response, response) &&
ec.Exception == null &&
Object.ReferenceEquals(ec.ActionContext, context)
)));
}
public void BindModel()
{
// Arrange
Mock <IModelBinder> mockKvpBinder = new Mock <IModelBinder>();
ModelBindingContext bindingContext = new ModelBindingContext
{
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IDictionary <int, string>)),
ModelName = "someName",
ValueProvider = new SimpleHttpValueProvider
{
{ "someName[0]", new KeyValuePair <int, string>(42, "forty-two") },
{ "someName[1]", new KeyValuePair <int, string>(84, "eighty-four") }
}
};
HttpActionContext context = ContextUtil.CreateActionContext();
context.ControllerContext.Configuration.ServiceResolver.SetService(typeof(ModelBinderProvider), (new SimpleModelBinderProvider(typeof(KeyValuePair <int, string>), mockKvpBinder.Object)));
mockKvpBinder
.Setup(o => o.BindModel(context, It.IsAny <ModelBindingContext>()))
.Returns((HttpActionContext cc, ModelBindingContext mbc) =>
{
mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
return(true);
});
// Act
bool retVal = new DictionaryModelBinder <int, string>().BindModel(context, bindingContext);
// Assert
Assert.True(retVal);
var dictionary = Assert.IsAssignableFrom <IDictionary <int, string> >(bindingContext.Model);
Assert.NotNull(dictionary);
Assert.Equal(2, dictionary.Count);
Assert.Equal("forty-two", dictionary[42]);
Assert.Equal("eighty-four", dictionary[84]);
}
public async Task ExecuteActionFilterAsync_CancellationTokenFlowsThrough()
{
// Arrange
HttpActionContext context = ContextUtil.CreateActionContext();
using (var cts = new CancellationTokenSource())
{
CancellationToken token = cts.Token;
Mock <ActionFilterAttribute> filterMock = new Mock <ActionFilterAttribute>()
{
CallBase = true,
};
var filter = (IActionFilter)filterMock.Object;
Func <Task <HttpResponseMessage> > continuation = () =>
Task.FromResult <HttpResponseMessage>(new HttpResponseMessage());
// Act
await filter.ExecuteActionFilterAsync(context, token, continuation);
// Assert
filterMock.Verify(
f =>
f.OnActionExecutingAsync(
It.IsAny <HttpActionContext>(),
It.Is <CancellationToken>(t => t == token)
)
);
filterMock.Verify(
f =>
f.OnActionExecutedAsync(
It.IsAny <HttpActionExecutedContext>(),
It.Is <CancellationToken>(t => t == token)
)
);
}
}
public void ExecuteAuthorizationFilterAsync_Traces()
{
// Arrange
Mock <AuthorizationFilterAttribute> mockAttr = new Mock <AuthorizationFilterAttribute>()
{
CallBase = true
};
Mock <HttpActionDescriptor> mockActionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection <HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
HttpActionContext actionContext = ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
Func <Task <HttpResponseMessage> > continuation = () => TaskHelpers.FromResult <HttpResponseMessage>(new HttpResponseMessage());
TestTraceWriter traceWriter = new TestTraceWriter();
AuthorizationFilterAttributeTracer tracer = new AuthorizationFilterAttributeTracer(mockAttr.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin, Operation = "OnAuthorization"
},
new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info)
{
Kind = TraceKind.End, Operation = "OnAuthorization"
},
};
// Act
Task task = ((IAuthorizationFilter)tracer).ExecuteAuthorizationFilterAsync(actionContext, CancellationToken.None, continuation);
task.Wait();
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
protected void Page_Load(object sender, EventArgs e)
{
byte[] byteData = null;
try
{
if (context == null)
{
context = ContextUtil.getInstance(Server.MapPath("."));
encrypt = context.getOuterEncrypt();
}
if (encoder == null)
encoder = ParamEncoder.getInstance();
if (decoder == null)
decoder = ParamDecoder.getInstance();
encoder.outEncoder = context.getOuterResolve();
decoder.outDecoder = context.getOuterResolve();
Stream input = Request.InputStream;
if (input.CanRead)
{
byteData = new byte[input.Length];
input.Read(byteData, 0, (int)input.Length);
input.Close();
input.Dispose();
// 解密
if (encrypt != null)
byteData = encrypt.decrypt(byteData);
dataVo = decoder.decoder(byteData);
Type serviceCls = context.getService(context.getServiceNameSpace() + "." + dataVo.ServiceName);
MethodInfo method = serviceCls.GetMethod(dataVo.MethodName);
object result = method.Invoke(System.Activator.CreateInstance(serviceCls), dataVo.Param);
dataVo.Result = result;
dataVo.ResultStatus = "success";
byte[] resultData = encoder.encode(dataVo);
if (encrypt != null)
resultData = encrypt.encrypt(resultData);
output = Response.OutputStream;
output.Write(resultData, 0, resultData.Length);
output.Flush();
output.Close();
output.Dispose();
}
else
{
}
}
catch(Exception exc)
{
if (dataVo == null && byteData != null)
dataVo = decoder.decoder(byteData);
if (dataVo == null)
dataVo = new DataVO();
dataVo.ResultStatus = "error";
dataVo.ErrorMessage = exc.ToString();
byte[] resultData = encoder.encode(dataVo);
if (encrypt != null)
resultData = encrypt.encrypt(resultData);
output = Response.OutputStream;
output.Write(resultData, 0, resultData.Length);
output.Flush();
output.Close();
output.Dispose();
}
}