public void TournamentAggregate_CanBeCreated_EmptyAggregateId_ErrorThrown()
{
Should.Throw <ArgumentNullException>(() =>
{
TournamentAggregate aggregate = TournamentAggregate.Create(Guid.Empty);
});
}
public void TournamentAggregate_CanBeCreated_IsCreated()
{
TournamentAggregate aggregate = TournamentAggregate.Create(TournamentTestData.AggregateId);
aggregate.ShouldNotBeNull();
aggregate.AggregateId.ShouldBe(TournamentTestData.AggregateId);
}
/// <summary>
/// Handles the command.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
private async Task HandleCommand(CreateTournamentCommand command,
CancellationToken cancellationToken)
{
// Rehydrate the aggregate
TournamentAggregate tournament = await this.TournamentRepository.GetLatestVersion(command.TournamentId, cancellationToken);
// Get the club to validate the input
GolfClubAggregate club = await this.GolfClubRepository.GetLatestVersion(command.GolfClubId, cancellationToken);
// bug #29 fixes (throw exception if club not created)
if (!club.HasBeenCreated)
{
throw new NotFoundException($"No created golf club found with Id {command.GolfClubId}");
}
// Club is valid, now check the measured course, this will throw exception if not found
MeasuredCourseDataTransferObject measuredCourse = club.GetMeasuredCourse(command.CreateTournamentRequest.MeasuredCourseId);
tournament.CreateTournament(command.CreateTournamentRequest.TournamentDate,
command.GolfClubId,
command.CreateTournamentRequest.MeasuredCourseId,
measuredCourse.StandardScratchScore,
command.CreateTournamentRequest.Name,
(PlayerCategory)command.CreateTournamentRequest.MemberCategory,
(TournamentFormat)command.CreateTournamentRequest.Format);
// Save the changes
await this.TournamentRepository.SaveChanges(tournament, cancellationToken);
// Setup the response
command.Response = new CreateTournamentResponse
{
TournamentId = command.TournamentId
};
}
public void TournamentAggregate_ProduceResult_ResultIsProduced()
{
TournamentAggregate tournamentAggregate = TournamentTestData.GetCompletedTournamentAggregateWithCSSCalculatedAggregate(20, 15, 23, 16, 0, 5);
tournamentAggregate.ProduceResult();
tournamentAggregate.HasResultBeenProduced.ShouldBeTrue();
List <PlayerScoreRecordDataTransferObject> scores = tournamentAggregate.GetScores();
scores.Any(s => s.Last9HolesScore == 0).ShouldBeFalse();
scores.Any(s => s.Last6HolesScore == 0).ShouldBeFalse();
scores.Any(s => s.Last3HolesScore == 0).ShouldBeFalse();
scores.Any(s => s.TournamentDivision == 0).ShouldBeFalse();
scores.Any(s => s.Position == 0).ShouldBeFalse();
scores.Any(s => s.MeasuredCourseId == Guid.Empty).ShouldBeFalse();
scores.Any(s => s.PlayerId == Guid.Empty).ShouldBeFalse();
scores.Any(s => s.NetScore == 0).ShouldBeFalse();
scores.Any(s => s.GrossScore == 0).ShouldBeFalse();
scores.Any(s => s.PlayingHandicap < 0).ShouldBeFalse();
scores.Any(s => s.PlayingHandicap > 36).ShouldBeFalse();
scores.Any(s => s.TournamentId == Guid.Empty).ShouldBeFalse();
scores.Any(s => s.ScoreDate == DateTime.MinValue).ShouldBeFalse();
scores.Any(s => s.GolfClubId == Guid.Empty).ShouldBeFalse();
scores.Any(s => s.HandicapCategory == 0).ShouldBeFalse();
scores.Any(s => s.HoleScores.Count() != 18).ShouldBeFalse();
scores.Any(s => s.CSS == 0).ShouldBeFalse();
}
private TournamentAggregate GetNewTournament()
{
return(TournamentAggregate.CreateNew(
_tournamentId,
_tournamentName,
_tournamentDescription));
}
public void publish_tournament_without_steps_should_throw()
{
var tournament = TournamentAggregate.Restore(_tournamentId, _tournamentName, _tournamentDescription, false,
DateTime.Now, DateTime.Now.AddDays(1), new List <StepEntity>());
Assert.Throws <DomainException>(() => tournament.Publish());
}
public async Task SignUpPlayerForTournament(Guid tournamentId,
Guid playerId, CancellationToken cancellationToken)
{
// Validate the tournament Id
TournamentAggregate tournament = await this.TournamentRepository.GetLatestVersion(tournamentId, cancellationToken);
PlayerAggregate player = await this.PlayerRepository.GetLatestVersion(playerId, cancellationToken);
if (!player.HasBeenRegistered)
{
throw new InvalidOperationException("A player must be registered to sign up for a club tournament");
}
try
{
GolfClubMembershipAggregate golfClubMembership = await this.ClubMembershipRepository.GetLatestVersion(tournament.GolfClubId, cancellationToken);
golfClubMembership.GetMembership(player.AggregateId, player.DateOfBirth, player.Gender);
}
catch (NotFoundException nex)
{
throw new InvalidOperationException("A player must be a member of the club to sign up for a club tournament");
}
tournament.SignUpForTournament(playerId);
await this.TournamentRepository.SaveChanges(tournament, cancellationToken);
}
private async Task <Tournament> ToModel(TournamentAggregate aggregate)
{
var tournament = await GetTournament(aggregate.Id.Value);
var removedSteps = GetRemovedSteps(aggregate, tournament);
var currentSteps = GetCurrentSteps(tournament)
.Where(step => !removedSteps.Contains(step))
.ToList();
var newSteps = GetNewSteps(aggregate, currentSteps);
currentSteps.ForEach(currentStep =>
{
var step = aggregate.Steps.First(m => m.Id.Value == currentStep.StepId);
currentStep.Order = step.Order;
currentStep.IsOptional = step.IsOptional;
});
newSteps.ForEach(tS => tournament.TournamentSteps.Add(tS));
_context.TournamentSteps.RemoveRange(removedSteps);
tournament.Name = aggregate.Name;
tournament.Description = aggregate.Description;
tournament.EndDate = aggregate.EndDate;
tournament.StartDate = aggregate.StartDate;
tournament.IsPublished = aggregate.IsPublished;
return(tournament);
}
public static TournamentAggregate GetCreatedTournamentAggregate()
{
TournamentAggregate aggregate = TournamentAggregate.Create(TournamentTestData.AggregateId);
aggregate.CreateTournament(TournamentTestData.TournamentDate, TournamentTestData.GolfClubId, TournamentTestData.MeasuredCourseId, TournamentTestData.MeasuredCourseSSS, TournamentTestData.Name, TournamentTestData.PlayerCategoryEnum, TournamentTestData.TournamentFormatEnum);
return(aggregate);
}
public void TournamentAggregate_CalculateCSS_CSSAlreadyCalculated_ErrorThrown()
{
TournamentAggregate aggregate = TournamentTestData.GetCompletedTournamentAggregate(1, 2, 7, 20, 5, 5);
aggregate.CalculateCSS();
Should.Throw <InvalidOperationException>(() => { aggregate.CalculateCSS(); });
}
public void TournamentAggregate_CompleteTournament_InvalidData_ErrorThrown(Boolean validCompleteDate)
{
TournamentAggregate aggregate = TournamentTestData.GetCreatedTournamentWithScoresRecordedAggregate();
DateTime completeDateTime = validCompleteDate ? TournamentTestData.CompletedDateTime : DateTime.MinValue;
Should.Throw <ArgumentNullException>(() => { aggregate.CompleteTournament(completeDateTime); });
}
public async Task <string> Handle(CreateTournamentCommand request, CancellationToken cancellationToken)
{
var tournament = TournamentAggregate.CreateNew(await _tournamentRepository.NextIdAsync(), request.Name,
request.Description);
await _tournamentRepository.SetAsync(tournament);
return(tournament.Id.ToString());
}
public void TournamentAggregate_GetScores_ScoresReturned()
{
TournamentAggregate aggregate = TournamentTestData.GetCreatedTournamentWithScoresRecordedAggregate();
List <PlayerScoreRecordDataTransferObject> scores = aggregate.GetScores();
scores.ShouldNotBeNull();
scores.Count.ShouldBe(1);
}
public void TournamentAggregate_CompleteTournament_TournamentComplete()
{
TournamentAggregate aggregate = TournamentTestData.GetCreatedTournamentWithScoresRecordedAggregate();
aggregate.CompleteTournament(TournamentTestData.CompletedDateTime);
aggregate.HasBeenCompleted.ShouldBeTrue();
aggregate.CompletedDateTime.ShouldBe(TournamentTestData.CompletedDateTime);
}
public async Task <TournamentId> SetAsync(TournamentAggregate aggregate)
{
var tournament = await ToModel(aggregate);
_context.Tournaments.Upsert(tournament);
await _context.SaveChangesAsync();
return(new TournamentId(tournament.Id));
}
public void TournamentAggregate_CancelTournament_InvalidData_ErrorThrown(Boolean validCancellationDate,
String cancellationReason)
{
TournamentAggregate aggregate = TournamentTestData.GetCreatedTournamentWithScoresRecordedAggregate();
DateTime cancellationDateTime = validCancellationDate ? TournamentTestData.CancelledDateTime : DateTime.MinValue;
Should.Throw <ArgumentNullException>(() => { aggregate.CancelTournament(cancellationDateTime, cancellationReason); });
}
public void set_start_date_equals_to_end_date_should_throw()
{
var endDate = DateTime.Now;
var tournament = TournamentAggregate.Restore(
_tournamentId, _tournamentName, _tournamentDescription,
false, endDate.AddDays(-1), endDate, new List <StepEntity>());
Assert.Throws <DomainException>(() => tournament.SetStartDate(endDate));
}
private static List <TournamentStep> GetNewSteps(TournamentAggregate aggregate,
List <TournamentStep> currentSteps)
{
return(aggregate.Steps
.Where(s => currentSteps.All(tS => tS.StepId != s.Id.Value))
.Select(s => new TournamentStep {
Order = s.Order, IsOptional = s.IsOptional, StepId = s.Id.Value
})
.ToList());
}
public void TournamentAggregate_CancelTournament_TournamentComplete()
{
TournamentAggregate aggregate = TournamentTestData.GetCreatedTournamentWithScoresRecordedAggregate();
aggregate.CancelTournament(TournamentTestData.CancelledDateTime, TournamentTestData.CancellationReason);
aggregate.HasBeenCancelled.ShouldBeTrue();
aggregate.CancelledDateTime.ShouldBe(TournamentTestData.CancelledDateTime);
aggregate.CancelledReason.ShouldBe(TournamentTestData.CancellationReason);
}
public void publish_tournament_without_end_date_should_throw()
{
var steps = new List <StepEntity> {
GetStep(0, false)
};
var tournament = TournamentAggregate.Restore(_tournamentId, _tournamentName, _tournamentDescription, false,
DateTime.Now, null, steps);
Assert.Throws <DomainException>(() => tournament.Publish());
}
public async Task <IActionResult> GetTournament([FromRoute] Guid tournamentId,
[FromQuery] Boolean includeScores,
CancellationToken cancellationToken)
{
TournamentAggregate tournament = await this.TournamentRepository.GetLatestVersion(tournamentId, cancellationToken);
if (!tournament.HasBeenCreated)
{
return(this.NotFound($"Tournament not found with Id {tournamentId}"));
}
Developer.DataTransferObjects.GetTournamentResponse response = new Developer.DataTransferObjects.GetTournamentResponse
{
HasBeenCreated = tournament.HasBeenCreated,
Name = tournament.Name,
GolfClubId = tournament.GolfClubId,
Adjustment = tournament.Adjustment,
CSS = tournament.CSS,
CSSHasBeenCalculated = tournament.CSSHasBeenCalculated,
CancelledDateTime = tournament.CancelledDateTime,
CancelledReason = tournament.CancelledReason,
CompletedDateTime = tournament.CompletedDateTime,
Format = tournament.Format.ConvertTo <TournamentFormat>(),
HasBeenCancelled = tournament.HasBeenCancelled,
HasBeenCompleted = tournament.HasBeenCompleted,
MeasuredCourseId = tournament.MeasuredCourseId,
MeasuredCourseSSS = tournament.MeasuredCourseSSS,
MemberCategory = tournament.PlayerCategory.ConvertTo <PlayerCategory>(),
TournamentDate = tournament.TournamentDate
};
if (includeScores)
{
List <PlayerScoreRecordDataTransferObject> scores = tournament.GetScores();
if (scores.Count > 0)
{
scores.ForEach(s =>
{
response.Scores.Add(new MemberScoreRecord
{
GrossScore = s.GrossScore,
PlayingHandicap = s.PlayingHandicap,
HandicapCategory = s.HandicapCategory,
HoleScores = s.HoleScores,
MemberId = s.PlayerId,
NetScore = s.NetScore
});
});
}
}
return(this.Ok(response));
}
public void TournamentAggregate_RecordPlayerScore_InvalidData_NegativeHoleScores_ErrorThrown(Int32 holeNumber)
{
TournamentAggregate aggregate = TournamentTestData.GetCreatedTournamentAggregateWithPlayerSignedUp();
Should.Throw <InvalidDataException>(() =>
{
aggregate.RecordPlayerScore(TournamentTestData.PlayerId,
TournamentTestData.PlayingHandicap,
TournamentTestData.HoleScoresNegativeScore(holeNumber));
});
}
public void TournamentAggregate_RecordPlayerScore_InvalidData_NotAllHoleScores_ErrorThrown()
{
TournamentAggregate aggregate = TournamentTestData.GetCreatedTournamentAggregateWithPlayerSignedUp();
Should.Throw <InvalidDataException>(() =>
{
aggregate.RecordPlayerScore(TournamentTestData.PlayerId,
TournamentTestData.PlayingHandicap,
TournamentTestData.HoleScoresNotAllPresent);
});
}
public void TournamentAggregate_RecordPlayerScore_TournamentNotCreated_ErrorThrown()
{
TournamentAggregate aggregate = TournamentTestData.GetEmptyTournamentAggregate();
Should.Throw <InvalidOperationException>(() =>
{
aggregate.RecordPlayerScore(TournamentTestData.PlayerId,
TournamentTestData.PlayingHandicap,
TournamentTestData.HoleScores);
});
}
public static TournamentAggregate GetCreatedTournamentWithScoresRecordedAggregate()
{
TournamentAggregate aggregate = TournamentAggregate.Create(TournamentTestData.AggregateId);
aggregate.CreateTournament(TournamentTestData.TournamentDate, TournamentTestData.GolfClubId, TournamentTestData.MeasuredCourseId, TournamentTestData.MeasuredCourseSSS, TournamentTestData.Name, TournamentTestData.PlayerCategoryEnum, TournamentTestData.TournamentFormatEnum);
aggregate.SignUpForTournament(TournamentTestData.PlayerId);
aggregate.RecordPlayerScore(TournamentTestData.PlayerId, TournamentTestData.PlayingHandicap, TournamentTestData.HoleScores);
return(aggregate);
}
public void TournamentAggregate_RecordPlayerScore_InvalidData_ErrorThrown(Boolean validPlayerId,
Int32 playingHandicap,
Boolean validHoleScores,
Type exceptionType)
{
TournamentAggregate aggregate = TournamentTestData.GetEmptyTournamentAggregate();
Guid playerId = validPlayerId ? TournamentTestData.PlayerId : Guid.Empty;
Dictionary <Int32, Int32> holeScores = validHoleScores ? TournamentTestData.HoleScores : null;
Should.Throw(() => { aggregate.RecordPlayerScore(playerId, playingHandicap, holeScores); }, exceptionType);
}
public void publish_tournament_should_works()
{
var steps = new List <StepEntity> {
GetStep(0, false)
};
var startDate = DateTime.Now;
var tournament = TournamentAggregate.Restore(_tournamentId, _tournamentName, _tournamentDescription, false,
startDate, startDate.AddDays(1), steps);
tournament.Publish();
Assert.AreEqual(true, tournament.IsPublished);
}
/// <summary>
/// Handles the command.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
private async Task HandleCommand(ProduceTournamentResultCommand command,
CancellationToken cancellationToken)
{
// Rehydrate the aggregate
TournamentAggregate tournament = await this.TournamentRepository.GetLatestVersion(command.TournamentId, cancellationToken);
// Produce the result
tournament.ProduceResult();
// Save the changes
await this.TournamentRepository.SaveChanges(tournament, cancellationToken);
}
/// <summary>
/// Handles the command.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
private async Task HandleCommand(CancelTournamentCommand command,
CancellationToken cancellationToken)
{
// Rehydrate the aggregate
TournamentAggregate tournament = await this.TournamentRepository.GetLatestVersion(command.TournamentId, cancellationToken);
DateTime cancelledDateTime = DateTime.Now;
tournament.CancelTournament(cancelledDateTime, command.CancelTournamentRequest.CancellationReason);
// Save the changes
await this.TournamentRepository.SaveChanges(tournament, cancellationToken);
}
/// <summary>
/// Handles the command.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
private async Task HandleCommand(RecordPlayerTournamentScoreCommand command,
CancellationToken cancellationToken)
{
// Rehydrate the aggregate
TournamentAggregate tournament = await this.TournamentRepository.GetLatestVersion(command.TournamentId, cancellationToken);
tournament.RecordPlayerScore(command.PlayerId,
command.RecordPlayerTournamentScoreRequest.PlayingHandicap,
command.RecordPlayerTournamentScoreRequest.HoleScores);
// Save the changes
await this.TournamentRepository.SaveChanges(tournament, cancellationToken);
}
