private IEnumerable <MetadataObjectContext> GetMetadataContexts(
IKey baseKey,
IList <IFastMemberWithValues> dependendArguments,
object[][] ctorValuesCollections,
IReadOnlyList <int> sortedToUnsorted,
ITestDataGenerator testDataGenerator)
{
var dependendArgumentMapping = new List <Tuple <int, IKey> >();
for (var i = 0; i < dependendArguments.Count; i++)
{
var argument = dependendArguments[i];
var argumentKey = baseKey.CreateKey(argument);
var argumentIndex = sortedToUnsorted[i];
dependendArgumentMapping.Add(new Tuple <int, IKey> (argumentIndex, argumentKey));
}
foreach (var valueCollection in ctorValuesCollections)
{
var context = new MetadataObjectContext(testDataGenerator);
foreach (var dependendArgument in dependendArgumentMapping)
{
context.Add(dependendArgument.Item2, valueCollection[dependendArgument.Item1]);
}
yield return(context);
}
}
private void CreateAndAssignAuto(object suite, ITestDataGenerator generator, AutoDataAttribute attribute, FieldInfo field)
{
var autoData = this.InvokeGenericMethod("CreateAutoData", new object[] { generator, attribute.MaxRecursionDepth }, new[] { field.FieldType });
attribute.CurrentSuite = suite;
attribute.Mutate(autoData);
field.SetValue(suite, autoData);
}
internal RuleBasedDataGenerator(ITestDataGenerator testDataGenerator, RuleSet ruleSet)
{
ArgumentUtility.CheckNotNull("testDataGenerator", testDataGenerator);
TestDataGenerator = testDataGenerator;
_random = testDataGenerator.Random;
_ruleSet = ruleSet;
InitialDataProvider = new InitialDataProvider(new GeneratorDataProvider());
}
public TestFileGenerator(ILogger <TestFileGenerator> logger, ITestDataGenerator testDataGenerator,
IFileSaver fileSaver, IFilenameGenerator filenameGenerator, IOptionsSnapshot <GeneratorConfiguration> options)
{
_logger = logger;
_testDataGenerator = testDataGenerator;
_fileSaver = fileSaver;
_filenameGenerator = filenameGenerator;
_generatorConfiguration = options.Value;
}
/// <summary>
/// Creates the player datav2.
/// </summary>
/// <param name="testDataGenerator">The test data generator.</param>
/// <param name="numberPlayersPerClub">The number players per club.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
private static async Task CreatePlayerDatav2(ITestDataGenerator testDataGenerator,
Int32 lastClub,
Int32 numberPlayersPerClub,
CancellationToken cancellationToken)
{
Int32 clubCounter = lastClub + 1;
foreach (GolfClubDetails golfClubDetails in Program.GolfClubs)
{
for (Int32 i = 0; i < numberPlayersPerClub; i++)
{
RegisterPlayerRequest registerPlayerRequest = new RegisterPlayerRequest
{
DateOfBirth = DateTime.Now.AddYears(-30),
EmailAddress = $"player{i}.{clubCounter}@testplayer.co.uk",
ExactHandicap = i,
GivenName = $"Club {clubCounter}",
Gender = "M",
FamilyName = $"Test Player {i}",
MiddleName = null
};
RegisterPlayerResponse registerPlayerResponse = await testDataGenerator.RegisterPlayer(registerPlayerRequest, cancellationToken);
Console.WriteLine($"Created Player {registerPlayerRequest.GivenName} {registerPlayerRequest.FamilyName}");
//String token = await testDataGenerator.GetToken(TokenType.Password,
// "developerClient",
// "developerClient",
// registerPlayerRequest.EmailAddress,
// "123456",
// new List<String>
// {
// "openid",
// "profile",
// "managementapi"
// });
await testDataGenerator.RequestClubMembership(Program.accessToken, registerPlayerResponse.PlayerId, golfClubDetails.GolfClubId, cancellationToken);
Console.WriteLine($"Player {registerPlayerRequest.GivenName} {registerPlayerRequest.FamilyName} membership requested");
Program.Players.Add(new PlayerDetails
{
GolfClubId = golfClubDetails.GolfClubId,
PlayerId = registerPlayerResponse.PlayerId,
PlayingHandicap = Convert.ToInt32(registerPlayerRequest.ExactHandicap), // TODO: Rounding
EmailAddress = registerPlayerRequest.EmailAddress
});
}
clubCounter++;
}
}
Context BaseContext(int seed)
{
return
(c => c
.Given("Empty domain with attribute based value provider", x =>
TestDataDomainConfiguration = (context => context
.UseDefaults(false)
.UseRandom(new DefaultRandom(seed))
.For <ClassWithMultipleAttributes>().AddProvider(new DefaultInstanceValueProvider <ClassWithMultipleAttributes>())
.For <ClassWithMultipleAttributes>().Select(cwma => cwma.Country).AddProvider(new CountryCityProvider())))
.Given("TestDataGenerator", x => TestDataGenerator = TestDataGeneratorFactory.Create(TestDataDomainConfiguration)));
}
Context BaseContext(int seed)
{
return
(c => c
.Given("Empty domain with date range value provider", x =>
TestDataDomainConfiguration = (context => context
.UseDefaults(false)
.UseRandom(new DefaultRandom(seed))
.For <ClassWithDateRange>().AddProvider(new DefaultInstanceValueProvider <ClassWithDateRange>())
.For <ClassWithDateRange>().Select(cwdr => cwdr.BirthDate).AddProvider(new DateGenerator())))
.Given("TestDataGenerator", x => TestDataGenerator = TestDataGeneratorFactory.Create(TestDataDomainConfiguration)));
}
Context BaseContext()
{
return
(c => c
.Given("{0,2,1}", x => InputList = new List <int> {
0, 2, 1
})
.Given("Empty domain with value provider", x =>
TestDataDomainConfiguration = (context => context
.UseDefaults(false)
.UseRandom(Random)
.For <string> ().AddProvider(new ChooseSingleItemValueProvider <int, string> (InputList, item => item.ToString()))))
.Given("TestDataGenerator", x => TestDataGenerator = TestDataGeneratorFactory.Create(TestDataDomainConfiguration)));
}
protected internal ValueProviderObjectContext(
ITestDataGenerator testDataGenerator,
Func <object, object> getPreviousValue,
Type targetValueType,
AdvancedContext advanced,
[CanBeNull] IFastMemberWithValues member)
{
TestDataGenerator = testDataGenerator;
Random = testDataGenerator.Random;
GetPreviousValue = getPreviousValue;
TargetValueType = targetValueType;
Advanced = advanced;
Member = member;
}
Context BaseContext()
{
return
(c =>
c
.Given("{0,1,2,3}", x => InputList = new List <int> {
0, 1, 2, 3
})
.Given("min: 2", x => MinItems = 2)
.Given("max: 4", x => MaxItems = 4)
.Given("Empty domain with value provider",
x =>
TestDataDomainConfiguration =
(context =>
context.UseDefaults(false)
.UseRandom(Random)
.For <IList <string> > ()
.AddProvider(new ChooseMultipleDistinctItemsValueProvider <int, string> (InputList, MinItems, MaxItems,
conversionFunc: item => item.ToString()))))
.Given("TestDataGenerator", x => TestDataGenerator = TestDataGeneratorFactory.Create(TestDataDomainConfiguration)));
}
/// <summary>
/// Creates the golf club datav2.
/// </summary>
/// <param name="testDataGenerator">The test data generator.</param>
/// <param name="numberOfGolfClubs">The number of golf clubs.</param>
/// <param name="lastClubCount">The last club count.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
private static async Task CreateGolfClubDatav2(ITestDataGenerator testDataGenerator,
Int32 numberOfGolfClubs,
Int32 lastClubCount,
CancellationToken cancellationToken)
{
List <Task> tasks = new List <Task>();
Int32 startIndex = 0 + lastClubCount;
Int32 endIndex = numberOfGolfClubs + lastClubCount;
for (Int32 i = startIndex; i < endIndex; i++)
{
RegisterClubAdministratorRequest registerClubAdministratorRequest = new RegisterClubAdministratorRequest
{
EmailAddress = $"clubadministrator@testgolfclub{i}.co.uk",
ConfirmPassword = "******",
Password = "******",
TelephoneNumber = "1234567890",
FamilyName = $"Admin {i}",
GivenName = "Club"
};
await testDataGenerator.RegisterGolfClubAdministrator(registerClubAdministratorRequest, cancellationToken);
String clubAdministratorToken = await testDataGenerator.GetToken(TokenType.Password,
"developerClient",
"developerClient",
registerClubAdministratorRequest.EmailAddress,
registerClubAdministratorRequest.Password,
new List <String>
{
"openid",
"profile",
"managementapi"
});
CreateGolfClubRequest createGolfClubRequest = new CreateGolfClubRequest
{
AddressLine1 = "Address Line 1",
AddressLine2 = "Address Line 2",
EmailAddress = $"contactus@testgolfclub{i}.co.uk",
TelephoneNumber = "1234567890",
Name = $"Test Golf Club {i}",
PostalCode = "TE57 1NG",
Region = "TestRegion",
Town = "TestTown",
Website = string.Empty
};
CreateGolfClubResponse createGolfClubResponse = await testDataGenerator.CreateGolfClub(clubAdministratorToken, createGolfClubRequest, cancellationToken);
await testDataGenerator.AddMeasuredCourseToGolfClub(Program.accessToken, createGolfClubResponse.GolfClubId, Program.AddMeasuredCourseToClubRequest, cancellationToken);
AddTournamentDivisionToGolfClubRequest division1 = new AddTournamentDivisionToGolfClubRequest
{
Division = 1,
StartHandicap = -10,
EndHandicap = 7
};
await testDataGenerator.AddTournamentDivision(Program.accessToken, createGolfClubResponse.GolfClubId, division1, cancellationToken);
AddTournamentDivisionToGolfClubRequest division2 = new AddTournamentDivisionToGolfClubRequest
{
Division = 2,
StartHandicap = 6,
EndHandicap = 12
};
await testDataGenerator.AddTournamentDivision(Program.accessToken, createGolfClubResponse.GolfClubId, division2, cancellationToken);
AddTournamentDivisionToGolfClubRequest division3 = new AddTournamentDivisionToGolfClubRequest
{
Division = 3,
StartHandicap = 13,
EndHandicap = 21
};
await testDataGenerator.AddTournamentDivision(Program.accessToken, createGolfClubResponse.GolfClubId, division3, cancellationToken);
AddTournamentDivisionToGolfClubRequest division4 = new AddTournamentDivisionToGolfClubRequest
{
Division = 4,
StartHandicap = 22,
EndHandicap = 28
};
await testDataGenerator.AddTournamentDivision(Program.accessToken, createGolfClubResponse.GolfClubId, division4, cancellationToken);
Program.GolfClubs.Add(new GolfClubDetails
{
AdminEmailAddress = registerClubAdministratorRequest.EmailAddress,
AdminPassword = registerClubAdministratorRequest.Password,
GolfClubId = createGolfClubResponse.GolfClubId,
MeasuredCourseId = Program.AddMeasuredCourseToClubRequest.MeasuredCourseId,
GolfClubName = createGolfClubRequest.Name
});
}
}
internal CompoundRuleExecutionContext(CompoundRuleInput inputData, ITestDataGenerator testDataGenerator, IReadableWorld world)
: base(testDataGenerator, world)
{
InputData = inputData;
}
private object CreateAutoData <T> (ITestDataGenerator generator, int maxRecursionDepth)
{
return(generator.Create <T>(maxRecursionDepth));
}
public CycleDataMatrix()
{
//初始化矩阵
Matrix = new AzimuthCell[AzimuthCellCount];
_testDataGenerator = new TargetSimulator(new AngleArea(20, 25));
}
private object CreateAutoData <T> (ITestDataGenerator generator, FieldInfo field, int maxRecursionDepth)
{
return(generator.Create <T>(maxRecursionDepth, _reflectionUtility.GetFieldInfo(field)));
}
internal SimpleRuleExecutionContext(ITestDataGenerator testDataGenerator, IReadableWorld world, RuleValue <T> input)
: base(testDataGenerator, world)
{
Input = input;
}
public MetadataObjectContext(ITestDataGenerator testDataGenerator)
{
TestDataGenerator = testDataGenerator;
_valueMapping = new Dictionary <IKey, object>();
}
/// <summary>
/// Creates the tournament datav2.
/// </summary>
/// <param name="testDataGenerator">The test data generator.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
private static async Task CreateTournamentDatav2(ITestDataGenerator testDataGenerator,
CancellationToken cancellationToken)
{
foreach (GolfClubDetails golfClubDetails in Program.GolfClubs)
{
List <CreateTournamentRequest> requests = Program.GetCreateTournamentRequests(golfClubDetails.MeasuredCourseId);
//String passwordToken = testDataGenerator.GetToken(golfClubDetails.AdminEmailAddress);
foreach (CreateTournamentRequest createTournamentRequest in requests)
{
CreateTournamentResponse createTournamentResponse =
await testDataGenerator.CreateTournament(Program.accessToken, golfClubDetails.GolfClubId, createTournamentRequest, cancellationToken);
Console.WriteLine($"Tournament {createTournamentRequest.Name} created for Club {golfClubDetails.GolfClubName}");
// Get the players for this club
List <PlayerDetails> playerList = Program.Players.Where(p => p.GolfClubId == golfClubDetails.GolfClubId).ToList();
foreach (PlayerDetails player in playerList)
{
Int32 counter = 0;
ScoreResult scoreResult = ScoreResult.Under;
if (counter == 0)
{
scoreResult = ScoreResult.Under;
counter++;
}
else if (counter == 1)
{
scoreResult = ScoreResult.Buffer;
counter++;
}
else
{
scoreResult = ScoreResult.Over;
counter = 0;
}
RecordPlayerTournamentScoreRequest recordPlayerTournamentScoreRequest = new RecordPlayerTournamentScoreRequest
{
PlayingHandicap = player.PlayingHandicap,
HoleScores =
Program.GetHoleScores(player.PlayingHandicap, scoreResult)
};
//String playerPasswordToken = testDataGenerator.GetToken(player.EmailAddress);
await testDataGenerator.SignUpPlayerForTournament(Program.accessToken, player.PlayerId, createTournamentResponse.TournamentId, cancellationToken);
await testDataGenerator.RecordPlayerScore(Program.accessToken,
player.PlayerId,
createTournamentResponse.TournamentId,
recordPlayerTournamentScoreRequest,
cancellationToken);
Console.WriteLine($"Tournament Score Recorded for Player {player.EmailAddress} for Tournament {createTournamentRequest.Name} at Golf Club {golfClubDetails.GolfClubName}");
}
}
}
}
internal RuleExecutionContext(ITestDataGenerator testDataGenerator, IReadableWorld world)
{
TestDataGenerator = testDataGenerator;
World = world;
}
