public void TestCreateTournament()
{
// Arrange
int TEST_STYLE_ID = 1;
int TEST_NUM_OF_STATIONS = 4;
var request = new CreateTournamentRequest(TEST_TOURNAMENT_ID, TEST_STYLE_ID, TEST_NUM_OF_STATIONS);
var expectedResponse = new Response <EmptyResponse>();
var mockClient = new Mock <ITournamentClient>();
mockClient.Setup(client => client.CreateTournament(request))
.Returns(expectedResponse.WithSuccess());
// Act
var tournamentController = new TournamentController(
requestFieldExtractor,
mockClient.Object);
var result = tournamentController.CreateTournament(request) as OkObjectResult;
var response = result.Value as Response <EmptyResponse>;
// Assert
Assert.NotNull(response);
Assert.True(response.IsSuccessStatusCode);
}
public async Task <IActionResult> CreateTournament(TournamentCreateModel model)
{
var request = new CreateTournamentRequest(model.TournamentName, model.TeamsCount);
var tournament = await _mediator.Send(request);
return(Ok(tournament.Name));
}
public async Task <IActionResult> CreateTournament([FromRoute] Guid golfClubId,
[FromBody] CreateTournamentRequest request,
CancellationToken cancellationToken)
{
Guid tournamentId = Guid.NewGuid();
// Get the Golf Club Id claim from the user
Claim golfClubIdClaim = ClaimsHelper.GetUserClaim(this.User, CustomClaims.GolfClubId, golfClubId.ToString());
Boolean validationResult = ClaimsHelper.ValidateRouteParameter(golfClubId, golfClubIdClaim);
if (validationResult == false)
{
return(this.Forbid());
}
// Create the command
CreateTournamentCommand command = CreateTournamentCommand.Create(tournamentId, Guid.Parse(golfClubIdClaim.Value), request);
// Route the command
await this.CommandRouter.Route(command, cancellationToken);
// return the result
return(this.Created($"{TournamentController.ControllerRoute}/{tournamentId}", new CreateTournamentResponse
{
TournamentId = tournamentId
}));
}
public async Task GolfClubController_POST_CreateTournament_TournamentIsCreated()
{
// 1. Arrange
HttpClient client = this.WebApplicationFactory.AddPlayer().CreateClient();
CreateTournamentRequest createTournamentRequest = TestData.CreateTournamentRequest;
String uri = $"api/golfclubs/{TestData.GolfClubId}/tournaments";
client.DefaultRequestHeaders.Add("api-version", "2.0");
StringContent content = Helpers.CreateStringContent(createTournamentRequest);
// 2. Act
HttpResponseMessage response = await client.PostAsync(uri, content, CancellationToken.None);
// 3. Assert
response.StatusCode.ShouldBe(HttpStatusCode.Created);
String responseAsJson = await response.Content.ReadAsStringAsync();
responseAsJson.ShouldNotBeNullOrEmpty();
CreateTournamentResponse responseObject = JsonConvert.DeserializeObject <CreateTournamentResponse>(responseAsJson);
responseObject.TournamentId.ShouldNotBe(Guid.Empty);
}
public async Task GivenWhenICreateATournamentWithTheFollowingDetails(Table table)
{
foreach (TableRow tableRow in table.Rows)
{
CreateGolfClubResponse createGolfClubResponse = this.TestingContext.GetCreateGolfClubResponse(tableRow["GolfClubNumber"]);
List <MeasuredCourseListResponse> measuredCourseList = await this.TestingContext.DockerHelper.GolfClubClient.GetMeasuredCourses(this.TestingContext.GolfClubAdministratorToken,
createGolfClubResponse.GolfClubId,
CancellationToken.None).ConfigureAwait(false);
MeasuredCourseListResponse measuredCourse = measuredCourseList.Single(m => m.Name == tableRow["MeasuredCourseName"]);
TournamentFormat tournamentFormat = Enum.Parse <TournamentFormat>(tableRow["TournamentFormat"], true);
PlayerCategory playerCategory = Enum.Parse <PlayerCategory>(tableRow["PlayerCategory"], true);
// Work out the tournament date
DateTime tournamentDate = this.CalculateTournamentDate(tableRow);
CreateTournamentRequest createTournamentRequest = new CreateTournamentRequest
{
Format = (Int32)tournamentFormat,
Name = tableRow["TournamentName"],
MeasuredCourseId = measuredCourse.MeasuredCourseId,
MemberCategory = (Int32)playerCategory,
TournamentDate = tournamentDate
};
this.TestingContext.CreateTournamentRequests.Add(new Tuple <String, String, String>(tableRow["GolfClubNumber"], tableRow["MeasuredCourseName"],
tableRow["TournamentNumber"]), createTournamentRequest);
}
}
/// <summary>
/// Creates the tournament.
/// </summary>
/// <param name="accessToken">The password token.</param>
/// <param name="golfClubId">The golf club identifier.</param>
/// <param name="createTournamentRequest">The create tournament request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <CreateTournamentResponse> CreateTournament(String accessToken,
Guid golfClubId,
CreateTournamentRequest createTournamentRequest,
CancellationToken cancellationToken)
{
return(await this.TournamentClient.CreateTournament(accessToken, golfClubId, createTournamentRequest, cancellationToken));
}
public async Task <CreateTournamentResponse> CreateTournament([FromBody] CreateTournamentRequest request)
{
string id = await tournamentService.CreateTournament(request);
return(new CreateTournamentResponse
{
TournamentId = id,
});
}
public Response <EmptyResponse> CreateTournament(CreateTournamentRequest request)
{
var response = client.PostAsync("tournament", RequestSerializer.Content(request)).Result;
if (response.IsSuccessStatusCode)
{
return(Newtonsoft.Json.JsonConvert.DeserializeObject <Response <EmptyResponse> >(response.Content.ReadAsStringAsync().Result));
}
return(new Response <EmptyResponse>(response.RequestMessage.ToString(), (int)response.StatusCode));
}
/// <summary>
/// Creates the tournament.
/// </summary>
/// <param name="accessToken">The access token.</param>
/// <param name="claimsIdentity">The claims identity.</param>
/// <param name="viewModel">The view model.</param>
/// <param name="cancellationToken">The cancellation token.</param>
public async Task CreateTournament(String accessToken,
ClaimsIdentity claimsIdentity,
CreateTournamentViewModel viewModel,
CancellationToken cancellationToken)
{
CreateTournamentRequest request = this.ModelFactory.ConvertFrom(viewModel);
Guid golfClubId = ApiClient.GetClaimValue <Guid>(claimsIdentity, "GolfClubId");
await this.TournamentClient.CreateTournament(accessToken, golfClubId, request, cancellationToken);
}
public async Task <IActionResult> CreateTournament([FromBody] CreateTournamentRequest request)
{
try
{
await tournamentService.Create(request.Date);
return(Ok());
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError, $"Bad time: {e.Message}"));
}
}
/// <summary>
/// Converts from.
/// </summary>
/// <param name="viewModel">The view model.</param>
/// <returns></returns>
public CreateTournamentRequest ConvertFrom(CreateTournamentViewModel viewModel)
{
CreateTournamentRequest request = new CreateTournamentRequest
{
Format = viewModel.Format,
MemberCategory = viewModel.MemberCategory,
MeasuredCourseId = viewModel.MeasuredCourseId,
TournamentDate = viewModel.TournamentDate.Value,
Name = viewModel.Name
};
return(request);
}
public void ModelFactory_ConvertFrom_CreateTournamentViewModel_ConvertedSuccessfully()
{
ModelFactory factory = new ModelFactory();
CreateTournamentViewModel viewModel = ModelFactoryTestData.GetCreateTournamentViewModel();
CreateTournamentRequest apiRequest = factory.ConvertFrom(viewModel);
apiRequest.Format.ShouldBe(viewModel.Format);
apiRequest.MeasuredCourseId.ShouldBe(viewModel.MeasuredCourseId);
apiRequest.MemberCategory.ShouldBe(viewModel.MemberCategory);
apiRequest.Name.ShouldBe(viewModel.Name);
apiRequest.TournamentDate.ShouldBe(viewModel.TournamentDate.Value);
}
public async void Create_ShouldReturnError_IfTournamentCreateFails()
{
var testDate = new DateTime(2020, 1, 1);
var request = new CreateTournamentRequest()
{
Date = testDate
};
mockTournamentService.Setup(x => x.Create(It.IsAny <DateTime>())).ThrowsAsync(new Exception("Bad time"));
var result = Assert.IsType <ObjectResult>(await tournamentController.CreateTournament(request));
Assert.Equal(StatusCodes.Status500InternalServerError, result.StatusCode);
}
public async void Create_ShouldReturnOk_IfTournamentCreated()
{
var testDate = new DateTime(2020, 1, 1);
var request = new CreateTournamentRequest()
{
Date = testDate
};
mockTournamentService.Setup(x => x.Create(testDate));
var result = Assert.IsType <OkResult>(await tournamentController.CreateTournament(request));
mockTournamentService.VerifyAll();
}
public async Task ThenTournamentNumberForGolfClubMeasuredCourseWillBeCreated(String tournamentNumber, String golfClubNumber, String measuredCourseName)
{
CreateTournamentRequest createTournamentRequest = this.TestingContext.GetCreateTournamentRequest(golfClubNumber, measuredCourseName, tournamentNumber);
CreateGolfClubResponse createGolfClubResponse = this.TestingContext.GetCreateGolfClubResponse(golfClubNumber);
CreateTournamentResponse createTournamentResponse = await this.TestingContext.DockerHelper.GolfClubClient
.CreateTournament(this.TestingContext.GolfClubAdministratorToken, createGolfClubResponse.GolfClubId, createTournamentRequest, CancellationToken.None)
.ConfigureAwait(false);
createTournamentResponse.TournamentId.ShouldNotBe(Guid.Empty);
this.TestingContext.CreateTournamentResponses.Add(new Tuple <String, String, String>(golfClubNumber, measuredCourseName,
tournamentNumber), createTournamentResponse);
}
public async Task TestCreateTournament()
{
// Arrange
int TEST_STYLE_ID = 1;
int TEST_NUM_OF_STATIONS = 4;
var request = new CreateTournamentRequest(TEST_TOURNAMENT_ID, TEST_STYLE_ID, TEST_NUM_OF_STATIONS);
// Act
var client = _testHostFixture.Client;
var response = await client.PostAsync("/api/tournament/create", RequestSerializer.Content(request));
// Assert
response
.StatusCode
.Should()
.Be(HttpStatusCode.OK);
}
public async Task <string> CreateTournament(CreateTournamentRequest request)
{
using (var command = connectionProvider.CreateCommand(@"
INSERT INTO Tournament (
id,
season,
title,
description,
location,
startDate,
endDate
)
VALUES (
@id,
@season,
@title,
@description,
@location,
@startDate,
@endDate
)
"))
{
string id = Guid.NewGuid().ToString();
command.AddParameter("@id", id);
command.AddParameter("@season", request.SeasonId);
command.AddParameter("@title", request.Title);
command.AddParameter("@description", request.Description);
command.AddParameter("@location", request.Location);
command.AddParameter("@startDate", request.StartDate);
command.AddParameter("@endDate", request.EndDate);
await command.ExecuteNonQueryAsync();
return(id);
}
}
/// <summary>
/// Creates the tournament.
/// </summary>
/// <param name="accessToken">The access token.</param>
/// <param name="golfClubId">The golf club identifier.</param>
/// <param name="request">The request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <CreateTournamentResponse> CreateTournament(String accessToken,
Guid golfClubId,
CreateTournamentRequest request,
CancellationToken cancellationToken)
{
CreateTournamentResponse response = null;
String requestUri = $"{this.BaseAddress}/api/golfclubs/{golfClubId}/tournaments";
try
{
String requestSerialised = JsonConvert.SerializeObject(request);
StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json");
// Add the access token to the client headers
this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
// Make the Http Call here
HttpResponseMessage httpResponse = await this.HttpClient.PostAsync(requestUri, httpContent, cancellationToken);
// Process the response
String content = await this.HandleResponse(httpResponse, cancellationToken);
// call was successful so now deserialise the body to the response object
response = JsonConvert.DeserializeObject <CreateTournamentResponse>(content);
}
catch (Exception ex)
{
// An exception has occurred, add some additional information to the message
Exception exception = new Exception($"Error creating the new tournament {request.Name}.", ex);
throw exception;
}
return(response);
}
public Response <EmptyResponse> CreateTournament(CreateTournamentRequest request)
{
var response = tournamentClient.CreateTournament(request);
return(response);
}
/// <summary>
/// Creates the specified create tournament request.
/// </summary>
/// <param name="tournamentId">The tournament identifier.</param>
/// <param name="golfClubId">The golf club identifier.</param>
/// <param name="createTournamentRequest">The create tournament request.</param>
/// <returns></returns>
public static CreateTournamentCommand Create(Guid tournamentId, Guid golfClubId, CreateTournamentRequest createTournamentRequest)
{
return(new CreateTournamentCommand(tournamentId, golfClubId, createTournamentRequest, Guid.NewGuid()));
}
public IActionResult CreateTournament([FromBody, Required] CreateTournamentRequest request)
{
var response = tournamentService.CreateTournament(request);
return(Ok(response));
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateTournamentCommand" /> class.
/// </summary>
/// <param name="tournamentId">The tournament identifier.</param>
/// <param name="golfClubId">The golf club identifier.</param>
/// <param name="createTournamentRequest">The create tournament request.</param>
/// <param name="commandId">The command identifier.</param>
private CreateTournamentCommand(Guid tournamentId, Guid golfClubId, CreateTournamentRequest createTournamentRequest, Guid commandId) : base(commandId)
{
this.TournamentId = tournamentId;
this.GolfClubId = golfClubId;
this.CreateTournamentRequest = createTournamentRequest;
}
