Example #1
0
            public async Task ShouldSucceedAsync(FakeCrudListRequest listRequest)
            {
                Assert.NotNull(listRequest);

                var authorizationService = MockAuthorizationServiceFactory();

                authorizationService.Setup(s =>
                                           s.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), "listPolicyName"))
                .Returns(async() => await Task.FromResult(AuthorizationResult.Success()).ConfigureAwait(false));

                var logger = MockLoggerFactory();

                var mediator = MockMediatorFactory();

                mediator.Setup(s => s.Send(It.IsAny <FakeCrudListQuery>(), It.IsAny <CancellationToken>())).Returns <FakeCrudListQuery, CancellationToken>(MockListMediatorHandlerAsync);

                var auditableCommandFactory = MockCommandFactory();

                var auditableQueryFactory = MockQueryFactory();

                auditableQueryFactory.Setup(s =>
                                            s.GetListQueryAsync(
                                                It.IsAny <FakeCrudListRequest>(),
                                                It.IsAny <ClaimsPrincipal>(),
                                                It.IsAny <CancellationToken>()))
                .Returns <FakeCrudListRequest, ClaimsPrincipal, CancellationToken>(MockListQueryAsync);

                using (var instance = new FakeCrudController(
                           authorizationService.Object,
                           logger.Object,
                           mediator.Object,
                           auditableCommandFactory.Object,
                           auditableQueryFactory.Object)
                {
                    ControllerContext = new ControllerContext
                    {
                        HttpContext = new DefaultHttpContext
                        {
                            User = new ClaimsPrincipal(new HttpListenerBasicIdentity("user", "pass")),
                            Request =
                            {
                                IsHttps = true,
                                Query   = new QueryCollection(),
                            },
                        },
                    },
                })
                {
                    var result = await instance.GetAsync(null, CancellationToken.None).ConfigureAwait(false);

                    Assert.NotNull(result);
                    Assert.IsType <OkObjectResult>(result);
                }
            }
Example #2
0
 /// <inheritdoc />
 protected override Task <FakeCrudListQuery> GetListQueryAsync(FakeCrudListRequest listRequestDto, ClaimsPrincipal claimsPrincipal,
                                                               CancellationToken cancellationToken)
 {
     return(Task.FromResult(new FakeCrudListQuery(listRequestDto, claimsPrincipal)));
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="FakeCrudListQuery"/> class.
 /// </summary>
 /// <param name="requestDto">the request dto.</param>
 /// <param name="claimsPrincipal">the claims principal associated with the request.</param>
 public FakeCrudListQuery(FakeCrudListRequest requestDto, ClaimsPrincipal claimsPrincipal)
     : base(requestDto, claimsPrincipal)
 {
 }
Example #4
0
 private static Task <FakeCrudListQuery> MockListQueryAsync(FakeCrudListRequest requestDto, ClaimsPrincipal claimsPrincipal, CancellationToken cancellationToken)
 {
     return(Task.FromResult(new FakeCrudListQuery(requestDto, claimsPrincipal)));
 }