public async Task Delete_WithValidCrew_ShouldDeleteCrew() { var authService = new Mock <IAuthorizationHelper>(); authService.Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), It.IsAny <string>())) .ReturnsAsync(AuthorizationResult.Success()); using (var context = provider.GetService <TimingSiteContext>()) using (var controller = new HeadRaceTimingSite.Api.Controllers.CrewController(authService.Object, mapper, context)) { Competition competition = new Competition { CompetitionId = 1 }; context.Competitions.Add(competition); Crew dbCrew = new Crew { BroeCrewId = 123456 }; competition.Crews.Add(dbCrew); context.SaveChanges(); var response = await controller.DeleteById(123456).ConfigureAwait(false); var noContentResult = response as NoContentResult; Assert.IsNotNull(noContentResult); Assert.AreEqual(204, noContentResult.StatusCode); Assert.AreEqual(0, context.Crews.Count()); Assert.AreEqual(0, competition.Crews.Count); } }
public void RendersNothingIfAuthorizedButNoChildContentOrAuthorizedProvided() { // Arrange var authorizationService = new TestAuthorizationService(); authorizationService.NextResult = AuthorizationResult.Success(); var renderer = CreateTestRenderer(authorizationService); var rootComponent = WrapInAuthorizeView(); rootComponent.AuthenticationState = CreateAuthenticationState("Nellie"); // Act renderer.AssignRootComponentId(rootComponent); rootComponent.TriggerRender(); // Assert var diff = renderer.Batches.Single().GetComponentDiffs <AuthorizeView>().Single(); Assert.Empty(diff.Edits); // Assert: The IAuthorizationService was given expected criteria Assert.Collection(authorizationService.AuthorizeCalls, call => { Assert.Equal("Nellie", call.user.Identity.Name); Assert.Null(call.resource); Assert.Collection(call.requirements, req => Assert.IsType <DenyAnonymousAuthorizationRequirement>(req)); }); }
public void GetPatientDetails_When_Called_With_Valid_Id_Returns_Expected_Type() { // Arrange SetupAuthorize(AuthorizationResult.Success()); var examination = new Examination { ExaminationId = "a" }; var examinationRetrievalService = new Mock <IAsyncQueryHandler <ExaminationRetrievalQuery, Examination> >(); examinationRetrievalService .Setup(service => service.Handle(It.IsAny <ExaminationRetrievalQuery>())) .Returns(Task.FromResult(examination)); var patientDetailsUpdateService = new Mock <IAsyncQueryHandler <PatientDetailsUpdateQuery, Examination> >(); var sut = new PatientDetailsController( LoggerMock.Object, Mapper, UsersRetrievalByOktaIdServiceMock.Object, AuthorizationServiceMock.Object, PermissionServiceMock.Object, examinationRetrievalService.Object, patientDetailsUpdateService.Object, _locationParentsQueryServiceMock.Object); // Act var response = sut.GetPatientDetails("a").Result; // Assert var taskResult = response.Should().BeOfType <ActionResult <GetPatientDetailsResponse> >().Subject; taskResult.Result.Should().BeAssignableTo <OkObjectResult>(); }
public async Task GetStats_StateUnderTest_ExpectedBehavior() { // Arrange var unitUnderTest = this.CreateDashboardController(); CancellationToken ct = new CancellationToken() { }; this.mockAuthorizationService.Setup( r => r.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <string>(), It.IsAny <string>()) ).ReturnsAsync(AuthorizationResult.Success()); this.mockDashboardBusiness.Setup( r => r.GetStatsAsync(It.IsAny <long>(), It.IsAny <CancellationToken>()) ).ReturnsAsync( new Dashboard() { LivesImpacted = 2, TotalEvents = 2 } ); // Act var result = await unitUnderTest.GetStats(ct); // Assert Assert.IsType <Dashboard>(result.Value); }
public void GetMedical_When_Called_With_No_MedicalTeam_InExamination_Returns_Expected_Type() { // Arrange SetupAuthorize(AuthorizationResult.Success()); var examinationId = Guid.NewGuid().ToString(); var examination = new Examination { ExaminationId = examinationId }; _examinationRetrievalServiceMock .Setup(service => service.Handle(It.IsAny <ExaminationRetrievalQuery>())) .Returns(Task.FromResult(examination)); Controller.ControllerContext = GetControllerContext(); // Act var response = Controller.GetMedicalTeam(examinationId).Result; // Assert var taskResult = response.Should().BeOfType <ActionResult <GetMedicalTeamResponse> >().Subject; var emptyResult = taskResult.Result.Should().BeAssignableTo <OkObjectResult>().Subject; var examinationIdReturned = (GetMedicalTeamResponse)emptyResult.Value; examinationIdReturned.MedicalExaminerUserId.Should().BeNull(); examinationIdReturned.MedicalExaminerFullName.Should().BeNull(); examinationIdReturned.MedicalExaminerGmcNumber.Should().BeNull(); examinationIdReturned.MedicalExaminerOfficerUserId.Should().BeNull(); examinationIdReturned.MedicalExaminerOfficerFullName.Should().BeNull(); examinationIdReturned.MedicalExaminerOfficerGmcNumber.Should().BeNull(); examinationIdReturned.NursingTeamInformation.Should().BeNull(); }
public void Setup() { this.playerMock = new Mock <IPlayer>(); this.authorization = new Mock <IAuthorizationFacade>(); this.passedArguments = Array.Empty <object>(); this.fakeExecutor = _ => { }; this.attribute = new CommandAttribute("grouped", "command"); this.authorization.Setup( x => x.AuthorizeAsync( It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), It.IsAny <AuthorizeAttribute[]>())) .ReturnsAsync(AuthorizationResult.Success()); this.handlerCommand = new HandlerCommand(this.authorization.Object, this.attribute, Array.Empty <AuthorizeAttribute>(), Array.Empty <string>(), new [] { new ParameterDefinition("player", typeof(IPlayer), false, null), new ParameterDefinition("allow", typeof(bool), false, null), new ParameterDefinition("message", typeof(string), true, "cool"), }, x => { this.fakeExecutor(x); return(this.passedArguments = x); }); }
public void PostMedicalTeam_MedicalteamUpdateServiceErrors_Returns_Expected_Type() { // Arrange SetupAuthorize(AuthorizationResult.Success()); var examinationId = Guid.NewGuid().ToString(); var examination = new Examination { ExaminationId = examinationId }; const Examination nullExamination = (Examination)null; var putMedicalTeamRequest = new PutMedicalTeamRequest(); UsersRetrievalByOktaIdServiceMock .Setup(service => service.Handle(It.IsAny <UserRetrievalByOktaIdQuery>())) .Returns(Task.FromResult(AuthorizedUser)); _examinationRetrievalServiceMock .Setup(service => service.Handle(It.IsAny <ExaminationRetrievalQuery>())) .Returns(Task.FromResult(examination)); _medicalTeamUpdateServiceMock .Setup(u => u.Handle(It.IsAny <Examination>(), "a")) .Returns(Task.FromResult(nullExamination)); Controller.ControllerContext = GetControllerContext(); // Act var response = Controller.PutMedicalTeam(examinationId, putMedicalTeamRequest).Result; // Assert var taskResult = response.Should().BeOfType <ActionResult <PutMedicalTeamResponse> >().Subject; taskResult.Result.Should().BeAssignableTo <BadRequestObjectResult>(); }
public async Task EditGet_ExistingAudio_ReturnsViewWithModelContainingExpectedAudioId() { var audio = new AudioBuilder().Build(); var audioService = Substitute.For <IAudioService>(); audioService .GetAudioAsync(audio.AudioId, Arg.Any <CancellationToken>()) .Returns(Task.FromResult(audio)); var authService = Substitute.For <IAuthorizationService>(); authService .AuthorizeAsync(Arg.Any <ClaimsPrincipal>(), audio, Arg.Any <IAuthorizationRequirement[]>()) .Returns(Task.FromResult(AuthorizationResult.Success())); var sut = new AudioControllerBuilder() .WithAudioService(audioService) .WithAuthService(authService) .WithMapper(new MapperBuilder().WithDefaultProfile().Build()) .Build(); var sutView = await sut.Edit(audio.AudioId, CancellationToken.None) as ViewResult; var actual = ((AudioViewModel)sutView.Model).AudioId; actual.Should().Be(audio.AudioId); }
public async Task OnPostEditLoanApplicationAsync_ReturnsNotFoundResult_WhenModelStateIsValid() { // Arrange var authorizationService = new Mock <IAuthorizationService>(); authorizationService.Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), It.IsAny <IEnumerable <IAuthorizationRequirement> >())) .ReturnsAsync(AuthorizationResult.Success()); var store = new Mock <IUserStore <IdentityUser> >(); var mgr = new Mock <UserManager <IdentityUser> >(store.Object, null, null, null, null, null, null, null, null); var httpContext = new DefaultHttpContext(); var modelState = new ModelStateDictionary(); var actionContext = new ActionContext(httpContext, new RouteData(), new PageActionDescriptor(), modelState); var modelMetadataProvider = new EmptyModelMetadataProvider(); var viewData = new ViewDataDictionary(modelMetadataProvider, modelState); var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>()); var pageContext = new PageContext(actionContext) { ViewData = viewData }; var loanId = 100; var pageModel = new EditModel(AppDbContext, authorizationService.Object, mgr.Object) { PageContext = pageContext, TempData = tempData, Url = new UrlHelper(actionContext), }; // Act // A new ModelStateDictionary is valid by default. var result = await pageModel.OnPostAsync(loanId); // Assert Assert.IsType <NotFoundResult>(result); }
public void Setup() { organizedGamesRepositoryMock = new Mock <IOrganizedGamesRepository>(); organizedGamesRepositoryMock.Setup(s => s.Add(It.IsAny <OrganizedGame>())).Returns(Task.FromResult(new OrganizedGame { Id = "created", StartTime = DateTime.Now, StartInterval = TimeSpan.FromMinutes(5), GameTypeId = "gameId" })); gamesRepositoryMock = new Mock <IGamesRepository>(); gamesRepositoryMock.Setup(s => s.Get("gameId")).Returns(new Game { Id = "gameId", CreatedBy = "user", Ready = true, Name = "test game" }); var mapperConfiguration = new MapperConfiguration(c => { c.AddProfile <OrganizedGameProfile>(); }); mapper = new Mapper(mapperConfiguration); authorizationServiceMock = new Mock <IAuthorizationService>(); authorizationServiceMock.Setup(s => s.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), It.IsAny <IEnumerable <IAuthorizationRequirement> >())) .Returns(Task.FromResult(AuthorizationResult.Success())); var httpContext = new Mock <HttpContext>(); httpContext.Setup(s => s.User).Returns(new ClaimsPrincipal()); httpContextAccessorMock = new Mock <IHttpContextAccessor>(); httpContextAccessorMock.Setup(s => s.HttpContext).Returns(httpContext.Object); }
public async Task EditPost_NoAudios_ReturnsNotFoundHttpCode() { var authService = Substitute.For <IAuthorizationService>(); authService .AuthorizeAsync(Arg.Any <ClaimsPrincipal>(), Arg.Any <Audio>(), Arg.Any <IAuthorizationRequirement[]>()) .Returns(Task.FromResult(AuthorizationResult.Success())); var audioService = Substitute.For <IAudioService>(); audioService .When(x => x.UpdateAudioAsync(Arg.Any <Audio>(), Arg.Any <CancellationToken>())) .Do(x => throw new KeyNotFoundException()); var sut = new AudioControllerBuilder() .WithAuthService(authService) .WithAudioService(audioService) .WithMapper(new MapperBuilder().WithDefaultProfile().Build()) .Build(); var sutView = await sut.Edit(new AudioViewModel(), CancellationToken.None) as ViewResult; var actual = sutView.StatusCode; actual.Should().Be(StatusCodes.Status404NotFound); }
protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, ApiKeyRequirement requirement) { if (context.User == null || !context.User.Identity.IsAuthenticated || !context.User.HasClaim(x => x.Type == ClaimTypes.Name)) { logger.LogWarning($"User isn't authenticated."); context.Fail(); return(Task.FromResult(AuthorizationFailure.Failed(new ApiKeyRequirement[] { }))); } var token = authRepository.GetAPITokenAsync(context.User.FindFirst(ClaimTypes.Name).Value).Result; var routeData = httpContextAccessor.HttpContext.GetRouteData(); if (!routeData.Values.TryGetValue("channelid", out object channelid)) { logger.LogWarning("Channel Id wasn't provided."); context.Fail(); return(Task.FromResult(AuthorizationFailure.Failed(new ApiKeyRequirement[] { }))); } if (!authRepository.IsAuthorizedToAPITokenCacheAsync(channelid.ToString(), token.Id).Result) { logger.LogWarning($"Channel Id({channelid}) isn't authorized to access token Id({token.Id})."); context.Fail(); return(Task.FromResult(AuthorizationFailure.Failed(new ApiKeyRequirement[] { }))); } context.Succeed(requirement); return(Task.FromResult(AuthorizationResult.Success())); }
public async Task GetUserById_StateUnderTest_ExpectedBehavior() { Guid myGuidVar = new Guid("9034b908-dc1f-41ad-b3f1-af416757753e"); // setup all needed values { this.mockAuthorizationService.Setup( r => r.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <string>(), It.IsAny <string>()) ).ReturnsAsync(AuthorizationResult.Success()); this.mockUserBusiness.Setup(r => r.GetUserIdAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(new Guid()); User usvar = new User() { FirstName = "Sample", LastName = "T", Id = myGuidVar }; this.mockUserBusiness.Setup(r => r.GetUserByIdAsync(It.IsAny <Guid>())).ReturnsAsync(usvar); } // Arrange var unitUnderTest = this.CreateUsersController(); // Act var result = await unitUnderTest.GetUserById(myGuidVar); // Assert Assert.True(result.Value.Id == myGuidVar); }
public async Task AuthService_GivenNamedPolicy_DoesAuthorize() { var testCase = ConfigureTestCase(builder => { builder.WithIdentity(user => { user.SetupGet(x => x.IsAuthenticated) .Returns(true); }) .WithMockAuthorizationService(authSvc => { authSvc.Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <TestLinkContainer>(), It.IsAny <string>())) .Returns(Task.FromResult(AuthorizationResult.Success())); }) .WithMockRouteMap(routeMap => { var methodInfoMock = new Mock <IControllerMethodInfo>(); routeMap.Setup(x => x.GetRoute(It.IsAny <string>())) .Returns <string>(routeName => new RouteInfo(routeName, HttpMethod.Get, methodInfoMock.Object)); }); }); var model = new TestLinkContainer(); var context = testCase.CreateContext(model, false, null, new[] { "Policy1" }); var result = await testCase.UnderTest.AuthorizeLink(context); Assert.True(result, "Expected authorization grant"); }
public void RendersAuthorizedContentIfAuthorized() { // Arrange var authorizationService = new TestAuthorizationService(); authorizationService.NextResult = AuthorizationResult.Success(); var renderer = CreateTestRenderer(authorizationService); var rootComponent = WrapInAuthorizeView( authorizedContent: context => builder => builder.AddContent(0, $"You are authenticated as {context.User.Identity.Name}")); rootComponent.AuthenticationState = CreateAuthenticationState("Nellie"); // Act renderer.AssignRootComponentId(rootComponent); rootComponent.TriggerRender(); // Assert var diff = renderer.Batches.Single().GetComponentDiffs<AuthorizeView>().Single(); Assert.Collection(diff.Edits, edit => { Assert.Equal(RenderTreeEditType.PrependFrame, edit.Type); AssertFrame.Text( renderer.Batches.Single().ReferenceFrames[edit.ReferenceFrameIndex], "You are authenticated as Nellie"); }); // Assert: The IAuthorizationService was given expected criteria Assert.Collection(authorizationService.AuthorizeCalls, call => { Assert.Equal("Nellie", call.user.Identity.Name); Assert.Null(call.resource); Assert.Collection(call.requirements, req => Assert.IsType<DenyAnonymousAuthorizationRequirement>(req)); }); }
public void TorrentDoneTestCaseOk() { var item = new DownloadItem { Type = DownloadType.DDL, State = DownloadState.Downloading, Hash = "ABCD" }; helper.Setup(x => x.IsLocalCall(It.IsAny <HttpContext>())).Returns(true); repository.Setup(x => x.FindAllUnarchived()).Returns(new List <DownloadItem> { item }); authorizationService .Setup( x => x.AuthorizeAsync( It.IsAny <ClaimsPrincipal>(), It.IsAny <DownloadItem>(), DownloadItemPolicies.TorrentDonePolicy)) .Returns(Task.FromResult(AuthorizationResult.Success())); var controller = new TorrentDoneController(logger.Object, repository.Object, authorizationService.Object, torrentService.Object, dispatcher.Object); var response = controller.TorrentDone(helper.Object, "ABCD"); Assert.AreEqual(200, response.StatusCode); }
public void SetPolicyResult(string policy, bool result) { var policyResult = result ? AuthorizationResult.Success() : AuthorizationResult.Failed(); Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), policy)) .ReturnsAsync(policyResult); }
public async Task GetAccountAsync_Should_Return_OkObjectResult_With_GetAccountResponse() { var authResult = AuthorizationResult.Success(); var getAccountTokenOutputQueries = new List <GetAccountTokenOutputQuery> { new GetAccountTokenOutputQuery(DateTimeOffset.UtcNow, DateTimeOffset.UtcNow.AddDays(1), TokenTypeEnumeration.AccountConfirmation, "123456") }; var getAccountOutputQuery = new GetAccountOutputQuery(Guid.NewGuid(), "*****@*****.**", true, DateTimeOffset.UtcNow, true, null, new List <Guid> { Guid.NewGuid() }, getAccountTokenOutputQueries); var accountTokens = getAccountOutputQuery.Tokens.Select(x => new AccountToken(x.Issued, x.Expires, TokenProfile.ConvertToAccountTokenTypeEnum(x.Type), x.Value)); var getAccountResponse = new GetAccountResponse(getAccountOutputQuery.Id, getAccountOutputQuery.Email, getAccountOutputQuery.Confirmed, getAccountOutputQuery.Created, getAccountOutputQuery.PasswordAssigned, getAccountOutputQuery.LastLogin, getAccountOutputQuery.Roles, accountTokens); _authorizationServiceMock .Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), It.IsAny <string>())) .ReturnsAsync(authResult); _getAccountQueryHandlerMock .Setup(x => x.HandleAsync(It.IsAny <GetAccountInputQuery>(), It.IsAny <CancellationToken>())) .ReturnsAsync(getAccountOutputQuery); _mapperMock.Setup(x => x.Map <GetAccountOutputQuery, GetAccountResponse>(It.IsAny <GetAccountOutputQuery>())) .Returns(getAccountResponse); var result = await _controller.GetAccountAsync(getAccountOutputQuery.Id); var okResult = result.As <OkObjectResult>(); okResult.Value.Should().BeEquivalentTo(getAccountResponse); }
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously public override async Task <AuthorizationResult> CanModifyAsync(MockEntity originalEntity, MockEntity modifiedEntity, IContextInfo ctx) { if (modifiedEntity.IsValid) { return(AuthorizationResult.Success()); } return(AuthorizationResult.Fail("The entity is not valid :( ", modifiedEntity)); }
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously public override async Task <AuthorizationResult> CanCreateAsync(MockEntity entity, IContextInfo ctx) { if (entity.IsValid) { return(AuthorizationResult.Success()); } return(AuthorizationResult.Fail("The entity is not valid :( ", entity)); }
public async Task GetAllEvents_StateUnderTest_ExpectedBehavior() { // Arrange var unitUnderTest = this.CreateEventsController(); PagingOptions pagingOptions = new PagingOptions() { Limit = 1, Offset = 1 }; SortOptions <Event, EventEntity> sortOptions = new SortOptions <Event, EventEntity>() { OrderBy = new string[] { "" } }; SearchOptions <Event, EventEntity> searchOptions = new SearchOptions <Event, EventEntity>() { Search = new string[] { "" } }; CancellationToken ct = new CancellationToken(); this.mockAuthorizationService.Setup( r => r.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <string>(), It.IsAny <string>()) ).ReturnsAsync(AuthorizationResult.Success()); List <Event> events = new List <Event>(); events.Add(new Event() { Id = new Guid(), EventName = "Test", CreatedAt = DateTime.Now }); events.Add(new Event() { Id = new Guid(), EventName = "Test 1", CreatedAt = DateTime.Now }); PagedResults <Event> sampleResult = new PagedResults <Event>() { Items = events }; this.mockEventBusiness.Setup(r => r.GetAllAsync( It.IsAny <PagingOptions>(), It.IsAny <SortOptions <Event, EventEntity> >(), It.IsAny <SearchOptions <Event, EventEntity> >(), It.IsAny <CancellationToken>()) ).ReturnsAsync(sampleResult); // Act var result = await unitUnderTest.GetAllEvents( pagingOptions, sortOptions, searchOptions, ct); // Assert Assert.True(result.Value != null); }
public Task <AuthorizationResult> AuthorizeAsync(ClaimsPrincipal user, Product product) { if (product.SellerId == user.FindFirst(ClaimTypes.NameIdentifier).Value) { return(Task.FromResult(AuthorizationResult.Success())); } return(Task.FromResult(AuthorizationResult.Failed())); }
public static IAuthorizationService GetStandardAuthorizationService(bool successful = true) { var fakeAuth = A.Fake <IAuthorizationService>(); A.CallTo(() => fakeAuth.AuthorizeAsync(new ClaimsPrincipal(), new object(), "Any")) .WithAnyArguments() .Returns(Task.FromResult(successful ? AuthorizationResult.Success() : AuthorizationResult.Failed())); return(fakeAuth); }
public async Task Put_WithExistingCrew_ShouldUpdateCrew() { var authService = new Mock <IAuthorizationHelper>(); authService.Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), It.IsAny <string>())) .ReturnsAsync(AuthorizationResult.Success()); using (var context = provider.GetService <TimingSiteContext>()) using (var controller = new HeadRaceTimingSite.Api.Controllers.CrewController(authService.Object, mapper, context)) { Competition competition = new Competition { CompetitionId = 1 }; context.Competitions.Add(competition); Crew dbCrew = new Crew { BroeCrewId = 123456, BoatClass = BoatClass.SingleScull, ClubCode = "ABC", IsTimeOnly = false, Name = "Another BC", StartNumber = 5, Status = Crew.ResultStatus.Dsq, CompetitionId = competition.CompetitionId, Competition = competition }; competition.Crews.Add(dbCrew); context.SaveChanges(); HeadRaceTimingSite.Api.Resources.Crew crew = new HeadRaceTimingSite.Api.Resources.Crew { Id = 123456, BoatClass = BoatClass.Eight, ClubCode = "LDR", IsTimeOnly = true, Name = "Leander A", StartNumber = 1, Status = Crew.ResultStatus.Dns, CompetitionId = competition.CompetitionId }; var result = await controller.Put(1, 123456, crew).ConfigureAwait(false); var noContentResult = result as NoContentResult; Assert.IsNotNull(noContentResult, "Should be No Content"); Assert.AreEqual(204, noContentResult.StatusCode); Assert.AreEqual(1, competition.Crews.Count, "Should be one crew"); Assert.AreEqual(123456, competition.Crews[0].BroeCrewId); Assert.AreEqual(BoatClass.Eight, competition.Crews[0].BoatClass); Assert.AreEqual("LDR", competition.Crews[0].ClubCode); Assert.AreEqual(true, competition.Crews[0].IsTimeOnly); Assert.AreEqual("Leander A", competition.Crews[0].Name); Assert.AreEqual(1, competition.Crews[0].StartNumber); Assert.AreEqual(Crew.ResultStatus.Dns, competition.Crews[0].Status); } }
public async Task GetAllEventStatusReport_StateUnderTest_ExpectedBehavior() { // Arrange var unitUnderTest = this.CreateReportsController(); this.mockAuthorizationService.Setup( r => r.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <string>(), It.IsAny <string>()) ).ReturnsAsync(AuthorizationResult.Success()); List <EventStatusReport> evsts = new List <EventStatusReport>(); evsts.Add(new EventStatusReport() { EventDate = DateTime.Now, EventName = "Desc 2", EventId = "1" }); evsts.Add(new EventStatusReport() { EventDate = DateTime.Now, EventName = "Desc 1", EventId = "2" }); PagedResults <EventStatusReport> sampleResult = new PagedResults <EventStatusReport>() { Items = evsts }; mockReportBusiness.Setup(r => r.GetAllReportAsync( It.IsAny <PagingOptions>(), It.IsAny <SortOptions <Event, EventEntity> >(), It.IsAny <SearchOptions <Event, EventEntity> >(), It.IsAny <CancellationToken>())).ReturnsAsync(sampleResult); PagingOptions pagingOptions = new PagingOptions() { Limit = 1, Offset = 1 }; SortOptions <Event, EventEntity> sortOptions = new SortOptions <Event, EventEntity>() { OrderBy = new string[] { "" } }; SearchOptions <Event, EventEntity> searchOptions = new SearchOptions <Event, EventEntity>() { Search = new string[] { "" } }; CancellationToken ct = new CancellationToken(); bool report = false; // Act var result = await unitUnderTest.GetAllEventStatusReport( pagingOptions, sortOptions, searchOptions, report, ct); // Assert Assert.IsType <FileContentResult>(result); }
protected override Task HandleRequirementAsync(AuthorizationHandlerContext context, ChannelRequirement requirement) { if (context.User == null || !context.User.Identity.IsAuthenticated || !context.User.HasClaim(x => x.Type == ClaimTypes.NameIdentifier)) { logger.LogWarning($"User isn't authenticated."); context.Fail(); return(Task.FromResult(AuthorizationFailure.Failed(new ChannelRequirement[] { }))); } var routeData = httpContextAccessor.HttpContext.GetRouteData(); long routeAccountId = 0, routeTokenId; if (!routeData.Values.TryGetValue("accountid", out object accountid) || !long.TryParse(accountid.ToString(), out routeAccountId)) { logger.LogWarning($"A valid Account Id wasn't provided, instead was provided {accountid}. "); context.Fail(); return(Task.FromResult(AuthorizationFailure.Failed(new ChannelRequirement[] { }))); } string authenticatedAccountId = context.User.FindFirst(ClaimTypes.NameIdentifier).Value; if (authenticatedAccountId != routeAccountId.ToString()) { logger.LogWarning($"Account Id ({routeAccountId}) provided is not the same as the account Id ({authenticatedAccountId}) of the authenticated user."); context.Fail(); return(Task.FromResult(AuthorizationFailure.Failed(new ChannelRequirement[] { }))); } if (routeData.Values.TryGetValue("channelid", out object routeChannelId)) { if (!authRepositort.IsAuthorizedToChannelCacheAsync(routeAccountId, routeChannelId.ToString()).Result) { logger.LogWarning($"Account Id({routeAccountId}) isn't authorized to access channel Id({routeChannelId})."); context.Fail(); return(Task.FromResult(AuthorizationFailure.Failed(new ChannelRequirement[] { }))); } if (routeData.Values.TryGetValue("tokenid", out object tokenid)) { if (!long.TryParse(tokenid.ToString(), out routeTokenId) || !authRepositort.IsAuthorizedToAPITokenCacheAsync(routeAccountId, routeChannelId.ToString(), routeTokenId).Result) { logger.LogWarning($"Account Id({routeAccountId}) isn't authorized to access channel Id({routeChannelId}) with token Id({routeTokenId})."); context.Fail(); return(Task.FromResult(AuthorizationFailure.Failed(new ChannelRequirement[] { }))); } } } context.Succeed(requirement); return(Task.FromResult(AuthorizationResult.Success())); }
public async Task only_the_startech_leader_of_the_same_startech_than_route_urls_startech_can_admin_the_members() { MockAuthorizationService(AuthorizationResult.Success()); AuthorizationFilterContext context = CreateHttpContext(); var target = Create(); await target.OnAuthorizationAsync(context); context.Result.Should().BeNull(); }
private async Task <AuthorizationResult> CheckAuthorize(List <IAuthorizeData> authorizeDataList, IRouteContext routeContext) { if (!authorizeDataList.Any()) { return(AuthorizationResult.Success()); } AuthorizationPolicy policy = await AuthorizationPolicy.CombineAsync(this.policyProvider, authorizeDataList); return(await this.authorizationService.AuthorizeAsync(routeContext.User, policy)); }
public AuthorizationResult Evaluate(AuthorizationHandlerContext context) { if (_config.CurrentValue.EnableSecurity) { return(_defaultEvaulator.Evaluate(context)); } else { return(AuthorizationResult.Success()); } }
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); } }