public void GolfClubAggregate_CanBeCreated_IsCreated()
{
GolfClubAggregate aggregate = GolfClubAggregate.Create(GolfClubTestData.AggregateId);
aggregate.ShouldNotBeNull();
aggregate.AggregateId.ShouldBe(GolfClubTestData.AggregateId);
}
public void GolfClubAggregate_CreateGolfClub_DuplicateCreateGolfClubCalled_ErrorThrown()
{
GolfClubAggregate aggregate = GolfClubAggregate.Create(GolfClubTestData.AggregateId);
Should.NotThrow(() =>
{
aggregate.CreateGolfClub(GolfClubTestData.Name,
GolfClubTestData.AddressLine1,
GolfClubTestData.AddressLine2,
GolfClubTestData.Town,
GolfClubTestData.Region,
GolfClubTestData.PostalCode,
GolfClubTestData.TelephoneNumber,
GolfClubTestData.Website,
GolfClubTestData.EmailAddress);
});
Should.Throw <InvalidOperationException>(() =>
{
aggregate.CreateGolfClub(GolfClubTestData.Name,
GolfClubTestData.AddressLine1,
GolfClubTestData.AddressLine2,
GolfClubTestData.Town,
GolfClubTestData.Region,
GolfClubTestData.PostalCode,
GolfClubTestData.TelephoneNumber,
GolfClubTestData.Website,
GolfClubTestData.EmailAddress);
});
}
public void GolfClubAggregate_AddTournamentDivision_NullTournamentDivision_ErrorThrown()
{
GolfClubAggregate aggregate = GolfClubTestData.GetGolfClubAggregateWithMeasuredCourse();
TournamentDivisionDataTransferObject tournamentDivision = null;
Should.Throw <ArgumentNullException>(() => { aggregate.AddTournamentDivision(tournamentDivision); });
}
public void GolfClubAggregate_CanBeCreated_EmptyAggregateId_ErrorThrown()
{
Should.Throw <ArgumentNullException>(() =>
{
GolfClubAggregate aggregate = GolfClubAggregate.Create(Guid.Empty);
});
}
/// <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 GolfClubAggregate_GetMeasuredCourse_MeasuredCourseWithHolesReturned()
{
GolfClubAggregate aggregate = GolfClubTestData.GetGolfClubAggregateWithMeasuredCourse();
MeasuredCourseDataTransferObject measuredCourseDataTransferObject = GolfClubTestData.GetMeasuredCourseToAdd();
MeasuredCourseDataTransferObject measuredCourse = aggregate.GetMeasuredCourse(measuredCourseDataTransferObject.MeasuredCourseId);
measuredCourse.ShouldNotBeNull();
measuredCourse.Name.ShouldBe(measuredCourseDataTransferObject.Name);
measuredCourse.StandardScratchScore.ShouldBe(measuredCourseDataTransferObject.StandardScratchScore);
measuredCourse.TeeColour.ShouldBe(measuredCourseDataTransferObject.TeeColour);
measuredCourse.Holes.Count.ShouldBe(measuredCourseDataTransferObject.Holes.Count);
IOrderedEnumerable <HoleDataTransferObject> resultHoles = measuredCourse.Holes.OrderBy(m => m.HoleNumber);
foreach (HoleDataTransferObject holeDataTransferObject in resultHoles)
{
HoleDataTransferObject orignalHole = measuredCourseDataTransferObject.Holes.Single(h => h.HoleNumber == holeDataTransferObject.HoleNumber);
holeDataTransferObject.HoleNumber.ShouldBe(orignalHole.HoleNumber);
holeDataTransferObject.LengthInMeters.ShouldBe(orignalHole.LengthInMeters);
holeDataTransferObject.LengthInYards.ShouldBe(orignalHole.LengthInYards);
holeDataTransferObject.Par.ShouldBe(orignalHole.Par);
holeDataTransferObject.StrokeIndex.ShouldBe(orignalHole.StrokeIndex);
}
}
/// <summary>
/// Requests the club membership.
/// </summary>
/// <param name="playerId">The player identifier.</param>
/// <param name="golfClubId">The golf club identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
/// <exception cref="InvalidDataException">
/// Unable to request club membership for a player that has not been registered
/// or
/// Unable to request club membership for a club that has not been created
/// </exception>
public async Task RequestClubMembership(Guid playerId, Guid golfClubId, CancellationToken cancellationToken)
{
// Rehydrate the golf club membership aggregate
GolfClubMembershipAggregate golfClubMembershipAggregate =
await this.GolfClubMembershipRepository.GetLatestVersion(golfClubId, cancellationToken);
// Validate the player id firstly
PlayerAggregate playerAggregate = await this.PlayerRepository.GetLatestVersion(playerId, cancellationToken);
if (!playerAggregate.HasBeenRegistered)
{
throw new InvalidDataException("Unable to request club membership for a player that has not been registered");
}
// Now validate the club
GolfClubAggregate golfClubAggregate =
await this.GolfClubRepository.GetLatestVersion(golfClubId, cancellationToken);
if (!golfClubAggregate.HasBeenCreated)
{
throw new InvalidDataException("Unable to request club membership for a club that has not been created");
}
// Ok all the data has been validated, now run through the aggregate rules
golfClubMembershipAggregate.RequestMembership(playerId,
playerAggregate.FullName,
playerAggregate.DateOfBirth,
playerAggregate.Gender,
DateTime.Now);
// Save any pending changes
await this.GolfClubMembershipRepository.SaveChanges(golfClubMembershipAggregate, cancellationToken);
}
public void GolfClubAggregate_AddTournamentDivision_DivisionAdded()
{
GolfClubAggregate aggregate = GolfClubTestData.GetGolfClubAggregateWithMeasuredCourse();
TournamentDivisionDataTransferObject tournamentDivision = GolfClubTestData.GetTournamentDivision1();
Should.NotThrow(() => { aggregate.AddTournamentDivision(tournamentDivision); });
}
public void GolfClubAggregate_AddTournamentDivision_ClubNotCreated_ErrorThrown()
{
GolfClubAggregate aggregate = GolfClubTestData.GetEmptyGolfClubAggregate();
TournamentDivisionDataTransferObject tournamentDivision = GolfClubTestData.GetTournamentDivision1();
Should.Throw <InvalidOperationException>(() => { aggregate.AddTournamentDivision(tournamentDivision); });
}
public void GolfClubAggregate_CreateGolfClub_GolfClubCreated()
{
GolfClubAggregate aggregate = GolfClubAggregate.Create(GolfClubTestData.AggregateId);
aggregate.CreateGolfClub(GolfClubTestData.Name,
GolfClubTestData.AddressLine1,
GolfClubTestData.AddressLine2,
GolfClubTestData.Town,
GolfClubTestData.Region,
GolfClubTestData.PostalCode,
GolfClubTestData.TelephoneNumber,
GolfClubTestData.Website,
GolfClubTestData.EmailAddress);
aggregate.ShouldNotBeNull();
aggregate.AggregateId.ShouldBe(GolfClubTestData.AggregateId);
aggregate.Name.ShouldBe(GolfClubTestData.Name);
aggregate.AddressLine1.ShouldBe(GolfClubTestData.AddressLine1);
aggregate.AddressLine2.ShouldBe(GolfClubTestData.AddressLine2);
aggregate.Town.ShouldBe(GolfClubTestData.Town);
aggregate.Region.ShouldBe(GolfClubTestData.Region);
aggregate.PostalCode.ShouldBe(GolfClubTestData.PostalCode);
aggregate.TelephoneNumber.ShouldBe(GolfClubTestData.TelephoneNumber);
aggregate.Website.ShouldBe(GolfClubTestData.Website);
aggregate.EmailAddress.ShouldBe(GolfClubTestData.EmailAddress);
aggregate.HasBeenCreated.ShouldBeTrue();
}
/// <summary>
/// Handles the command.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
private async Task HandleCommand(CreateGolfClubCommand command,
CancellationToken cancellationToken)
{
Guid golfClubAggregateId = command.GolfClubId;
// Rehydrate the aggregate
GolfClubAggregate golfClubAggregate = await this.GolfClubRepository.GetLatestVersion(golfClubAggregateId, cancellationToken);
// Call the aggregate method
golfClubAggregate.CreateGolfClub(command.CreateGolfClubRequest.Name,
command.CreateGolfClubRequest.AddressLine1,
command.CreateGolfClubRequest.AddressLine2,
command.CreateGolfClubRequest.Town,
command.CreateGolfClubRequest.Region,
command.CreateGolfClubRequest.PostalCode,
command.CreateGolfClubRequest.TelephoneNumber,
command.CreateGolfClubRequest.Website,
command.CreateGolfClubRequest.EmailAddress);
// Record club admin user against aggregate
golfClubAggregate.CreateGolfClubAdministratorSecurityUser(command.SecurityUserId);
// Save the changes
await this.GolfClubRepository.SaveChanges(golfClubAggregate, cancellationToken);
// Setup the response
command.Response = new CreateGolfClubResponse
{
GolfClubId = golfClubAggregateId
};
}
public void GolfClubAggregate_AddMeasuredCourse_InvalidNumberOfHoles_ErrorThrown(Int32 numberHoles)
{
GolfClubAggregate aggregate = GolfClubTestData.GetCreatedGolfClubAggregate();
MeasuredCourseDataTransferObject measuredCourseDataTransferObject = GolfClubTestData.GetMeasuredCourseToAdd(numberHoles);
Should.Throw <InvalidDataException>(() => { aggregate.AddMeasuredCourse(measuredCourseDataTransferObject); });
}
public void GolfClubAggregate_GetMeasuredCourse_MeasuredCourseNotFound_ErrorThrown()
{
GolfClubAggregate aggregate = GolfClubTestData.GetGolfClubAggregateWithMeasuredCourse();
MeasuredCourseDataTransferObject measuredCourseDataTransferObject = GolfClubTestData.GetMeasuredCourseToAdd();
Should.Throw <NotFoundException>(() => { aggregate.GetMeasuredCourse(GolfClubTestData.InvalidMeasuredCourseId); });
}
public void GolfClubAggregate_AddMeasuredCourse_InvalidHoleData_MissingHoleNumber_ErrorThrown(Int32 holeNumber)
{
GolfClubAggregate aggregate = GolfClubTestData.GetCreatedGolfClubAggregate();
MeasuredCourseDataTransferObject measuredCourseDataTransferObject = GolfClubTestData.GetMeasuredCourseToAddWithMissingHoles(holeNumber);
Should.Throw <InvalidDataException>(() => { aggregate.AddMeasuredCourse(measuredCourseDataTransferObject); });
}
public void GolfClubAggregate_GetMeasuredCourses_NoCourses_ErrorThrown()
{
GolfClubAggregate aggregate = GolfClubTestData.GetCreatedGolfClubAggregate();
MeasuredCourseDataTransferObject measuredCourseDataTransferObject = GolfClubTestData.GetMeasuredCourseToAdd();
Should.Throw <NotFoundException>(() => { aggregate.GetMeasuredCourses(); });
}
public void GolfClubAggregate_AddMeasuredCourse_ClubNotCreated_ErrorThrown()
{
GolfClubAggregate aggregate = GolfClubTestData.GetEmptyGolfClubAggregate();
MeasuredCourseDataTransferObject measuredCourseDataTransferObject = GolfClubTestData.GetMeasuredCourseToAdd();
Should.Throw <InvalidOperationException>(() => { aggregate.AddMeasuredCourse(measuredCourseDataTransferObject); });
}
public void GolfClubAggregate_AddTournamentDivision_DuplicateDivision_ErrorThrown()
{
GolfClubAggregate aggregate = GolfClubTestData.GetGolfClubAggregateWithMeasuredCourse();
TournamentDivisionDataTransferObject tournamentDivision = GolfClubTestData.GetTournamentDivision1();
aggregate.AddTournamentDivision(tournamentDivision);
Should.Throw <InvalidOperationException>(() => { aggregate.AddTournamentDivision(tournamentDivision); });
}
public void GolfClubAggregate_CreateGolfClubAdministratorSecurityUser_GolfClubAdministratorSecurityUserCreated()
{
GolfClubAggregate aggregate = GolfClubTestData.GetCreatedGolfClubAggregate();
aggregate.CreateGolfClubAdministratorSecurityUser(GolfClubTestData.GolfClubAdministratorSecurityUserId);
aggregate.GolfClubAdministratorSecurityUserId.ShouldBe(GolfClubTestData.GolfClubAdministratorSecurityUserId);
aggregate.HasAdminSecurityUserBeenCreated.ShouldBeTrue();
}
public void GolfClubAggregate_AddMeasuredCourse_InvalidHoleData_InvalidData_ErrorThrown(Int32 lengthInYards,
Int32 par)
{
GolfClubAggregate aggregate = GolfClubTestData.GetCreatedGolfClubAggregate();
MeasuredCourseDataTransferObject measuredCourseDataTransferObject = GolfClubTestData.GetMeasuredCourseToAdd();
measuredCourseDataTransferObject.Holes.First().LengthInYards = lengthInYards;
measuredCourseDataTransferObject.Holes.First().Par = par;
Should.Throw <InvalidDataException>(() => { aggregate.AddMeasuredCourse(measuredCourseDataTransferObject); });
}
public async Task <IActionResult> GetGolfClub([FromRoute] Guid golfClubId,
[FromQuery] Boolean includeMemberships,
CancellationToken cancellationToken)
{
GolfClubAggregate golfClub = await this.GolfClubRepository.GetLatestVersion(golfClubId, cancellationToken);
if (!golfClub.HasBeenCreated)
{
return(this.NotFound($"Golf Club not found with Id {golfClubId}"));
}
// Translate to Developer DTO
DeveloperGetGolfClubResponse response = new DeveloperGetGolfClubResponse
{
AddressLine1 = golfClub.AddressLine1,
Name = golfClub.Name,
Town = golfClub.Town,
Website = golfClub.Website,
Region = golfClub.Region,
TelephoneNumber = golfClub.TelephoneNumber,
EmailAddress = golfClub.EmailAddress,
PostalCode = golfClub.PostalCode,
AggregateId = golfClub.AggregateId,
AddressLine2 = golfClub.AddressLine2,
HasBeenCreated = golfClub.HasBeenCreated
};
if (includeMemberships)
{
GolfClubMembershipAggregate golfClubMemberships = await this.GolfClubMembershipRepository.GetLatestVersion(golfClubId, cancellationToken);
List <MembershipDataTransferObject> memberships = golfClubMemberships.GetMemberships();
memberships.ForEach(m =>
{
response.GolfClubMemberships.Add(new GolfClubMembershipResponse
{
AcceptedDateAndTime = m.AcceptedDateAndTime,
MembershipId = m.MembershipId,
MembershipNumber = m.MembershipNumber,
PlayerDateOfBirth = m.PlayerDateOfBirth,
PlayerFullName = m.PlayerFullName,
PlayerGender = m.PlayerGender,
PlayerId = m.PlayerId,
RejectedDateAndTime = m.RejectedDateAndTime,
RejectionReason = m.RejectionReason,
Status = m.Status
});
});
}
return(this.Ok(response));
}
public void GolfClubAggregate_GetMeasuredCourses_MeasuredCoursesReturned()
{
GolfClubAggregate aggregate = GolfClubTestData.GetGolfClubAggregateWithMeasuredCourse();
MeasuredCourseDataTransferObject measuredCourseDataTransferObject = GolfClubTestData.GetMeasuredCourseToAdd();
List <MeasuredCourseDataTransferObject> measuredCourses = aggregate.GetMeasuredCourses();
measuredCourses.ShouldNotBeEmpty();
measuredCourses.First().MeasuredCourseId.ShouldBe(measuredCourseDataTransferObject.MeasuredCourseId);
measuredCourses.First().Name.ShouldBe(measuredCourseDataTransferObject.Name);
measuredCourses.First().TeeColour.ShouldBe(measuredCourseDataTransferObject.TeeColour);
measuredCourses.First().StandardScratchScore.ShouldBe(measuredCourseDataTransferObject.StandardScratchScore);
}
public void GolfClubAggregate_AddTournamentDivision_InvalidDivisionData_ErrorThrown(Int32 division,
Int32 startHandicap,
Int32 endHandicap,
Type exceptionType)
{
GolfClubAggregate aggregate = GolfClubTestData.GetGolfClubAggregateWithMeasuredCourse();
TournamentDivisionDataTransferObject tournamentDivision = new TournamentDivisionDataTransferObject
{
Division = division,
EndHandicap = endHandicap,
StartHandicap = startHandicap
};
Should.Throw(() => { aggregate.AddTournamentDivision(tournamentDivision); }, exceptionType);
}
public void GolfClubAggregate_AddMeasuredCourse_InvalidCourseData_ErrorThrown(Boolean validMeasuredCourseId,
String name,
String teeColour,
Int32 standardScratchScore)
{
GolfClubAggregate aggregate = GolfClubTestData.GetCreatedGolfClubAggregate();
MeasuredCourseDataTransferObject measuredCourseDataTransferObject = GolfClubTestData.GetMeasuredCourseToAdd();
measuredCourseDataTransferObject.MeasuredCourseId = validMeasuredCourseId ? GolfClubTestData.MeasuredCourseId : Guid.Empty;
measuredCourseDataTransferObject.Name = name;
measuredCourseDataTransferObject.TeeColour = teeColour;
measuredCourseDataTransferObject.StandardScratchScore = standardScratchScore;
Should.Throw <ArgumentNullException>(() => { aggregate.AddMeasuredCourse(measuredCourseDataTransferObject); });
}
public void GolfClubAggregate_AddTournamentDivision_DivisionStartHandicapClashesWithExistingRange_ErrorThrown()
{
GolfClubAggregate aggregate = GolfClubTestData.GetGolfClubAggregateWithMeasuredCourse();
TournamentDivisionDataTransferObject tournamentDivision = GolfClubTestData.GetTournamentDivision1();
aggregate.AddTournamentDivision(tournamentDivision);
TournamentDivisionDataTransferObject tournamentDivisionInvalid = new TournamentDivisionDataTransferObject
{
Division = 2,
EndHandicap = 12,
StartHandicap = GolfClubTestData.GetTournamentDivision1().StartHandicap
};
Should.Throw <InvalidDataException>(() => { aggregate.AddTournamentDivision(tournamentDivisionInvalid); });
}
/// <summary>
/// Handles the command.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
private async Task HandleCommand(AddTournamentDivisionToGolfClubCommand command,
CancellationToken cancellationToken)
{
// Rehydrate the aggregate
GolfClubAggregate golfClubAggregate = await this.GolfClubRepository.GetLatestVersion(command.GolfClubId, cancellationToken);
// Create the dto from the request in the command
TournamentDivisionDataTransferObject tournamentDivisionDataTransferObject = new TournamentDivisionDataTransferObject
{
Division = command.AddTournamentDivisionToGolfClubRequest.Division,
StartHandicap = command.AddTournamentDivisionToGolfClubRequest.StartHandicap,
EndHandicap = command.AddTournamentDivisionToGolfClubRequest.EndHandicap
};
golfClubAggregate.AddTournamentDivision(tournamentDivisionDataTransferObject);
await this.GolfClubRepository.SaveChanges(golfClubAggregate, cancellationToken);
}
public void GolfClubAggregate_CreateGolfClub_InvalidData_ErrorThrown(String name,
String addressLine1,
String town,
String region,
String postalCode)
{
GolfClubAggregate aggregate = GolfClubAggregate.Create(GolfClubTestData.AggregateId);
Should.Throw <ArgumentNullException>(() =>
{
aggregate.CreateGolfClub(name,
addressLine1,
GolfClubTestData.AddressLine2,
town,
region,
postalCode,
GolfClubTestData.TelephoneNumber,
GolfClubTestData.Website,
GolfClubTestData.EmailAddress);
});
}
/// <summary>
/// Handles the command.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
private async Task HandleCommand(AddMeasuredCourseToClubCommand command,
CancellationToken cancellationToken)
{
// Rehydrate the aggregate
GolfClubAggregate golfClubAggregate = await this.GolfClubRepository.GetLatestVersion(command.GolfClubId, cancellationToken);
// Translate the request to the input for AddMeasuredCourse
MeasuredCourseDataTransferObject measuredCourse = new MeasuredCourseDataTransferObject
{
MeasuredCourseId = command.MeasuredCourseId,
Name = command.AddMeasuredCourseToClubRequest.Name,
StandardScratchScore = command.AddMeasuredCourseToClubRequest.StandardScratchScore,
TeeColour = command.AddMeasuredCourseToClubRequest.TeeColour,
Holes = new List <HoleDataTransferObject>()
};
foreach (HoleDataTransferObjectRequest holeDataTransferObject in command.AddMeasuredCourseToClubRequest.Holes)
{
measuredCourse.Holes.Add(new HoleDataTransferObject
{
HoleNumber = holeDataTransferObject.HoleNumber,
Par = holeDataTransferObject.Par,
StrokeIndex = holeDataTransferObject.StrokeIndex,
LengthInYards = holeDataTransferObject.LengthInYards,
LengthInMeters = holeDataTransferObject.LengthInMeters
});
}
// Add the measured course
golfClubAggregate.AddMeasuredCourse(measuredCourse);
// Save the changes
await this.GolfClubRepository.SaveChanges(golfClubAggregate, cancellationToken);
// No Response to set
}
/// <summary>
/// Handles the command.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
private async Task HandleCommand(CreateMatchSecretaryCommand command,
CancellationToken cancellationToken)
{
Guid golfClubAggregateId = command.GolfClubId;
// Rehydrate the aggregate
GolfClubAggregate golfClubAggregate = await this.GolfClubRepository.GetLatestVersion(golfClubAggregateId, cancellationToken);
// Create the user
RegisterUserRequest registerUserRequest = new RegisterUserRequest
{
EmailAddress = command.CreateMatchSecretaryRequest.EmailAddress,
Claims = new Dictionary <String, String>
{
{ "GolfClubId", golfClubAggregateId.ToString() }
},
Password = "******",
PhoneNumber = command.CreateMatchSecretaryRequest.TelephoneNumber,
MiddleName = command.CreateMatchSecretaryRequest.MiddleName,
FamilyName = command.CreateMatchSecretaryRequest.FamilyName,
GivenName = command.CreateMatchSecretaryRequest.GivenName,
Roles = new List <String>
{
RoleNames.MatchSecretary
}
};
// Create the user
RegisterUserResponse registerUserResponse = await this.OAuth2SecurityService.RegisterUser(registerUserRequest, cancellationToken);
// Record against the aggregate
golfClubAggregate.CreateMatchSecretarySecurityUser(registerUserResponse.UserId);
// Save the changes
await this.GolfClubRepository.SaveChanges(golfClubAggregate, cancellationToken);
}
public void GolfClubAggregate_CreateMatchSecretarySecurityUser_InvalidData_ErrorThrown()
{
GolfClubAggregate aggregate = GolfClubTestData.GetEmptyGolfClubAggregate();
Should.Throw <ArgumentNullException>(() => { aggregate.CreateMatchSecretarySecurityUser(Guid.Empty); });
}
public void GolfClubAggregate_CreateMatchSecretarySecurityUser_MatchSecretaryUserAdded()
{
GolfClubAggregate aggregate = GolfClubTestData.GetCreatedGolfClubAggregate();
Should.NotThrow(() => { aggregate.CreateMatchSecretarySecurityUser(GolfClubTestData.MatchSecretarySecurityUserId); });
}
