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);
}
}
