public async Task SetsStatusCode(HttpActionExecutedContext context, JSendExceptionFilterAttribute filter)
 {
     // Exercise system
     await filter.OnExceptionAsync(context, CancellationToken.None);
     // Verify outcome
     context.Response.StatusCode.Should().Be(HttpStatusCode.InternalServerError);
 }
        public async Task SetsContentTypeHeader(HttpActionExecutedContext context, JSendExceptionFilterAttribute filter)
        {
            // Exercise system
            await filter.OnExceptionAsync(context, CancellationToken.None);

            // Verify outcome
            context.Response.Content.Headers.ContentType.MediaType.Should().Be("application/json");
        }
        public async Task SetsStatusCode(HttpActionExecutedContext context, JSendExceptionFilterAttribute filter)
        {
            // Exercise system
            await filter.OnExceptionAsync(context, CancellationToken.None);

            // Verify outcome
            context.Response.StatusCode.Should().Be(HttpStatusCode.InternalServerError);
        }
 public async Task CreatesResponse(HttpActionExecutedContext context, JSendExceptionFilterAttribute filter)
 {
     // Fixture setup
     context.Response = null;
     // Exercise system
     await filter.OnExceptionAsync(context, CancellationToken.None);
     // Verify outcome
     context.Response.Should().NotBeNull();
 }
        public async Task CreatesResponse(HttpActionExecutedContext context, JSendExceptionFilterAttribute filter)
        {
            // Fixture setup
            context.Response = null;
            // Exercise system
            await filter.OnExceptionAsync(context, CancellationToken.None);

            // Verify outcome
            context.Response.Should().NotBeNull();
        }
        public async Task CreatesErrorResponseWithoutDetails(HttpRequestContext requestContext,
            HttpActionExecutedContext context, JSendExceptionFilterAttribute filter)
        {
            // Fixture setup
            requestContext.IncludeErrorDetail = false;
            context.Request.SetRequestContext(requestContext);

            var expectedMessage =
                JsonConvert.SerializeObject(new ErrorResponse(StringResources.DefaultErrorMessage));
            // Exercise system
            await filter.OnExceptionAsync(context, CancellationToken.None);
            // Verify outcome
            var message = await context.Response.Content.ReadAsStringAsync();
            message.Should().Be(expectedMessage);
        }
Exemplo n.º 7
0
        public void ExceptionToJSend(Exception exception)
        {
            #region Arrange
            var serviceProviderMock = new Mock <IServiceProvider>();
            serviceProviderMock.Setup(serviceProvider => serviceProvider.GetService(typeof(ILogger <ResultFilterAttribute>)))
            .Returns(Mock.Of <ILogger <ResultFilterAttribute> >());

            var httpContext = new DefaultHttpContext()
            {
                RequestServices = serviceProviderMock.Object
            };

            var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor());


            var exceptionContext = new ExceptionContext(
                actionContext: actionContext,
                filters: new List <IFilterMetadata>())
            {
                Exception = exception
            };

            var exceptionFilter = new JSendExceptionFilterAttribute();
            #endregion

            #region Act
            exceptionFilter.OnException(exceptionContext);
            #endregion

            #region Assert

            JSendErrorResult result = Assert.IsAssignableFrom <JSendErrorResult>(exceptionContext.Result);
            Assert.Equal(500, result.StatusCode);

            Assert.IsAssignableFrom <IJSendResponse>(result.Value);

            var errorResponse = Assert.IsAssignableFrom <ErrorResponse>(result.Value);

            Assert.Equal("error", errorResponse.Status);

            Assert.Equal(exception.Message, errorResponse.Message);
            Assert.Equal(exception, errorResponse.Data);
            #endregion
        }
        public async Task CreatesErrorResponseWithoutDetails(HttpRequestContext requestContext,
                                                             HttpActionExecutedContext context, JSendExceptionFilterAttribute filter)
        {
            // Fixture setup
            requestContext.IncludeErrorDetail = false;
            context.Request.SetRequestContext(requestContext);

            var expectedMessage =
                JsonConvert.SerializeObject(new ErrorResponse(StringResources.DefaultErrorMessage));
            // Exercise system
            await filter.OnExceptionAsync(context, CancellationToken.None);

            // Verify outcome
            var message = await context.Response.Content.ReadAsStringAsync();

            message.Should().Be(expectedMessage);
        }
 public void ThrowsWhenContextIsNull(JSendExceptionFilterAttribute filter)
 {
     // Exercise system and verify outcome
     filter.Awaiting(f => f.OnExceptionAsync(null, CancellationToken.None))
     .ShouldThrow <ArgumentNullException>();
 }
 public void IsExceptionFilterAttribute(JSendExceptionFilterAttribute filter)
 {
     // Exercise system
     filter.Should().BeAssignableTo <ExceptionFilterAttribute>();
 }
 public async Task SetsContentTypeHeader(HttpActionExecutedContext context, JSendExceptionFilterAttribute filter)
 {
     // Exercise system
     await filter.OnExceptionAsync(context, CancellationToken.None);
     // Verify outcome
     context.Response.Content.Headers.ContentType.MediaType.Should().Be("application/json");
 }
 public void ThrowsWhenContextIsNull(JSendExceptionFilterAttribute filter)
 {
     // Exercise system and verify outcome
     filter.Awaiting(f => f.OnExceptionAsync(null, CancellationToken.None))
         .ShouldThrow<ArgumentNullException>();
 }
 public void IsExceptionFilterAttribute(JSendExceptionFilterAttribute filter)
 {
     // Exercise system
     filter.Should().BeAssignableTo<ExceptionFilterAttribute>();
 }