private int GetTotalRecords(ReadValidInput valueType)
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PartitionApiFields.RequestType, 1 }
};
ReadResponseData <Partition> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Partition>(parameters);
Assume.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, partition));
Assume.That(result.Total, Is.GreaterThan(1), Enums.Message.TOTAL_ERROR);
Assume.That(result.Items.Count, Is.GreaterThan(1), Enums.Message.COUNT_ERROR);
int tempStart = 0;
if (ReadValidInput.RandomStart == valueType)
{
tempStart = Util.GetRandomNumber(1, result.Total - 1); //Read a random of start and must be less than total - 1
}
else if (ReadValidInput.StartEqualToTotalSubtract1 == valueType)
{
tempStart = result.Total - 1; //Read start = total - 1
}
return(tempStart);
}
public void TestReadValid(string fieldName, ReadValidInput valueType)
{
int fieldValue = FieldValueMapperRead.ValidInputMapper[valueType];
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
};
if (valueType != ReadValidInput.NoParameter)
{
parameters.Add(fieldName, fieldValue);
}
ReadAndVerifyData(parameters, valueType, fieldName, fieldValue);
}
public void TestReadValidInput(Enums.ResourceType resourceType, ReadValidInput valueType)
{
string fieldAlias = customFields.Data[$"{resourceType}"].Field.ToAlias();
Assume.That(fieldAlias, Is.Not.Null.And.Not.Empty, "Cannot create a user field for " + resourceType);
string fieldValue = FieldValueMapperRead.ValidInputMapper[valueType];
XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType);
resource.DictionaryValues[fieldAlias] = fieldValue;
string id = ResourceHelper.WriteResource(resource, cleaner);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType.ToString()));
//Read & verify the field's value
DateTimeValidator.ReadAndVerifyDate(resourceType, id, fieldAlias, fieldValue);
}
public void TestReadValidInput(Enums.ResourceType resourceType, ReadValidInput valueType)
{
string fieldAlias = $"{resourceType.ToResourceName()}.{AppField}";
string fieldValue = FieldValueMapperRead.ValidInputMapper[valueType];
//Check registered application field
FieldHelper.CheckRegisteredField(readFields, resourceType, AppField);
XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType);
resource.DictionaryValues[fieldAlias] = fieldValue;
string id = ResourceHelper.WriteResource(resource, cleaner);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType.ToString()));
//Read & verify the field's value
DateTimeValidator.ReadAndVerifyDate(resourceType, id, fieldAlias, fieldValue);
}
public void TestReadValidInputPhase(string fieldName, ReadValidInput valueType)
{
Enums.ResourceType resourceType = Enums.ResourceType.Client;
string fieldValue = FieldValueMapperRead.ValidInputMapper[valueType];
string id = recordsWithoutFieldInput.Data[$"{resourceType.ToPrivateEnum()}0"].Id.ToString();
var phase = FieldHelper.CreatePhaseInstance(resourceType, id);
if (valueType != ReadValidInput.NotSpecifiedDate)
{
phase.DictionaryValues[fieldName] = fieldValue;
}
id = ResourceHelper.WriteResource(phase, null);
Assume.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, nameof(Phase)));
//Read & verify the field's value
if (valueType != ReadValidInput.NotSpecifiedDate)
{
DateTimeValidator.ReadAndVerifyDateForPhase(resourceType, id, fieldName, fieldValue);
}
else
{
DateTimeValidator.ReadAndVerifyAutoDesignatedDateForPhase(resourceType, id, fieldName);
}
if (valueType == ReadValidInput.NoValidation)
{
fieldValue = Util.ParseDateTime(FieldValueMapperRead.ValidInputMapper[ReadValidInput.NoValidation]).AddDays(1).ToString();
var phaseUpdate = new Phase
{
Id = id,
};
phaseUpdate.DictionaryValues[fieldName] = fieldValue;
id = ResourceHelper.WriteResource(phaseUpdate, null);
Assume.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, nameof(Phase)));
DateTimeValidator.ReadAndVerifyNoValidationDateForPhase(resourceType, id, fieldName);
}
}
public void TestReadValidInput(Enums.ResourceType resourceType, string fieldName, ReadValidInput valueType)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{fieldName}";
string fieldValue = FieldValueMapperRead.ValidInputMapper[valueType];
string id = null;
if (valueType != ReadValidInput.NotSpecifiedDate)
{
id = recordsWithFieldInput.Data[$"{resourceType.ToPrivateEnum()}{fieldName}{valueType}0"].Id.ToString();
}
else
{
id = recordsWithoutFieldInput.Data[$"{resourceType.ToPrivateEnum()}{fieldName}{valueType}0"].Id.ToString();
}
//Read & verify the field's value
if (valueType != ReadValidInput.NotSpecifiedDate)
{
DateTimeValidator.ReadAndVerifyDate(resourceType, id, fieldAlias, fieldValue);
}
else
{
DateTimeValidator.ReadAndVerifyAutoDesignatedDate(resourceType, id, fieldAlias);
}
if (valueType == ReadValidInput.NoValidation)
{
fieldValue = Util.ParseDateTime(FieldValueMapperRead.ValidInputMapper[ReadValidInput.NoValidation]).AddDays(1).ToString();
id = ResourceHelper.WriteResource(ResourceHelper.CreateUpdatedResource(resourceType, id, fieldAlias, fieldValue), cleaner);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName));
DateTimeValidator.ReadAndVerifyNoValidationDate(resourceType, id, fieldAlias);
}
}
/// <summary>
/// Verify data of fields
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="inputType">Value type</param>
/// <param name="fieldName">Field name</param>
/// <param name="fieldValue">Field value</param>
private void ReadAndVerifyData(Enums.ResourceType resourceType, ReadValidInput inputType, string fieldName, string fieldValue)
{
ReadResponseData <Field> result = null;
int startFromParamValue = 0;
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ FieldApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ FieldApiFields.Resource, (int)resourceType },
};
switch (inputType)
{
case ReadValidInput.RandomStart:
var totalCount = GetAllFields(resourceType).Count;
startFromParamValue = Util.GetRandomNumber(1, (totalCount > 200 ? 200 : totalCount) - 1);
parameters.Add(fieldName, startFromParamValue);
break;
case ReadValidInput.StartEqualToTotalSubtract1:
totalCount = GetAllFields(resourceType).Count;
startFromParamValue = (totalCount > 200 ? 200 : totalCount) - 1;
parameters.Add(fieldName, startFromParamValue);
break;
case ReadValidInput.Active0:
case ReadValidInput.Active1:
case ReadValidInput.ActiveMinus1:
//To test IsActive feature we need as many fields as possible so the result would be most accurate
parameters.Add(FieldApiFields.Count, MaxReadBatchSize);
parameters.Add(fieldName, fieldValue);
break;
case ReadValidInput.NoParameter:
if (fieldName == FieldApiFields.Active)
{
//To test IsActive feature we need as many fields as possible so the result would be most accurate
parameters.Add(FieldApiFields.Count, MaxReadBatchSize);
}
break;
default:
parameters.Add(fieldName, fieldValue);
break;
}
result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Field>(parameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, "Field"));
switch (inputType)
{
case ReadValidInput.NoParameter:
if (fieldName == FieldApiFields.Count)
{
Assert.That(result.Count, Is.EqualTo(SystemApiHelper.defaultCount), Enums.Message.COUNT_ERROR);
}
if (fieldName == FieldApiFields.Start)
{
Assert.That(result.Start, Is.EqualTo(SystemApiHelper.defaultStart), Enums.Message.START_ERROR);
}
if (fieldName == FieldApiFields.Active)
{
//Without active, verify that both of active 0 and 1 existed
VerifyFieldsHaveProperActiveStatus(result, GetAllFields(resourceType)); //VerifyActiveStatus(parameters, result, resourceType, -1); // All : -1
}
break;
case ReadValidInput.Count10:
Assert.That(result.Count, Is.EqualTo(SystemApiHelper.defaultCount), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.RandomCount:
Assert.That(result.Count, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.MaxCount:
Assert.That(result.Count, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.COUNT_ERROR);
Assert.That(result.Items.Count, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.Start0:
Assert.That(result.Start, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.START_ERROR);
break;
case ReadValidInput.RandomStart:
case ReadValidInput.StartEqualToTotalSubtract1:
Assert.That(result.Start, Is.EqualTo(startFromParamValue), Enums.Message.START_ERROR);
break;
case ReadValidInput.Active1:
VerifyFieldsHaveProperActiveStatus(result, GetActiveFields(resourceType));
break;
case ReadValidInput.Active0:
VerifyFieldsHaveProperActiveStatus(result, GetInactiveFields(resourceType));
break;
case ReadValidInput.ActiveMinus1:
VerifyFieldsHaveProperActiveStatus(result, GetAllFields(resourceType));
break;
}
}
public void TestReadValidCombine(Enums.ResourceType resourceType, string fieldName, ReadValidInput inputType)
{
string fieldValue = FieldValueMapperRead.ValidInputMapper[inputType];
ReadAndVerifyResource(resourceType);
ReadAndVerifyData(resourceType, inputType, fieldName, fieldValue);
}
public void TestReadValidOthers(string fieldName, ReadValidInput inputType)
{
string fieldValue = FieldValueMapperRead.ValidInputMapper[inputType];
ReadAndVerifyData(Enums.ResourceType.Job, inputType, fieldName, fieldValue);
}
public void TestReadValidInput(Enums.ResourceType resourceType, string fieldName, ReadValidInput valueType)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = string.Format("{0}.{1}", resourceName, fieldName);
string fieldValue = FieldValueMapperRead.ValidInputMapper[valueType];
XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType);
resource.DictionaryValues[fieldAlias] = fieldValue;
string id = ResourceHelper.WriteResource(resource, cleaner);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName));
//Read & verify the field's value
DateTimeValidator.ReadAndVerifyDate(resourceType, id, fieldAlias, fieldValue);
}
public void TestReadValidInput(Enums.ResourceType resourceType, string fieldName, ReadValidInput valueType)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = string.Format("{0}.{1}", resourceName, fieldName);
string fieldValue = FieldValueMapperRead.ValidInputMapper[valueType];
XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType);
resource.DictionaryValues[fieldAlias] = fieldValue;
if (fieldName == DateTimeSystemField.PhaseDate)
{
List <string> phaseList = OptionFieldHelper.GetOptionList($"Option.P_{resourceName}Phase");
Assume.That(phaseList, Is.Not.Null.And.Not.Empty, $"Cannot get the phase list of {resourceName}");
resource.DictionaryValues[$"{resourceName}.P_Phase"] = new Option()
{
ActualXMLTag = phaseList.First()
};
}
else
if (fieldName == DateTimeSystemField.ActivityToDate)
{
resource.DictionaryValues[$"{resourceName}.{DateTimeSystemField.ActivityFromDate}"] = fieldValue;
}
string id = ResourceHelper.WriteResource(resource, cleaner);
Assert.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceName));
//Read & verify the field's value
DateTimeValidator.ReadAndVerifyDate(resourceType, id, fieldAlias, fieldValue);
}
/// <summary>
/// Verify data of fields
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="inputType">Value type</param>
/// <param name="fieldName">Field name</param>
/// <param name="fieldValue">Field value</param>
private void ReadAndVerifyData(Enums.ResourceType resourceType, ReadValidInput inputType, string fieldName, string fieldValue)
{
int startFromParamValue = 0;
string resourceId = records.Data[$"{resourceType.ToPrivateEnum()}0"].Id.ToString();
string phaseId = string.Empty;
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ PhaseApiFields.Resource, (int)resourceType },
};
switch (inputType)
{
case ReadValidInput.RandomStart:
startFromParamValue = Util.GetRandomNumber(1, MaxReadBatchSize - 1);
parameters.Add(fieldName, startFromParamValue);
break;
case ReadValidInput.StartEqualToTotalSubtract1:
startFromParamValue = MaxReadBatchSize - 1;
parameters.Add(fieldName, startFromParamValue);
break;
case ReadValidInput.NoParameter:
break;
case ReadValidInput.ResourceId:
parameters.Add(fieldName, resourceId);
parameters.Add(PhaseApiFields.Field, nameof(PhaseApiFields.ResourceId));
break;
case ReadValidInput.Id:
phaseId = PhaseHelper.CreatePhase(resourceType, resourceId);
parameters.Add(fieldName, phaseId);
parameters.Add(PhaseApiFields.Field, nameof(PhaseApiFields.Id));
break;
default:
parameters.Add(fieldName, fieldValue);
break;
}
var result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Phase>(parameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, "Phase"));
switch (inputType)
{
case ReadValidInput.NoParameter:
if (fieldName == PhaseApiFields.Count)
{
Assert.That(result.Count, Is.EqualTo(SystemApiHelper.defaultCount), Enums.Message.COUNT_ERROR);
}
if (fieldName == PhaseApiFields.Start)
{
Assert.That(result.Start, Is.EqualTo(SystemApiHelper.defaultStart), Enums.Message.START_ERROR);
}
break;
case ReadValidInput.Count10:
Assert.That(result.Count, Is.EqualTo(SystemApiHelper.defaultCount), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.RandomCount:
Assert.That(result.Count, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.MaxCount:
Assert.That(result.Count, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.COUNT_ERROR);
Assert.That(result.Items.Count, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.Start0:
case ReadValidInput.Start0000:
Assert.That(result.Start, Is.EqualTo(int.Parse(fieldValue)), Enums.Message.START_ERROR);
break;
case ReadValidInput.RandomStart:
case ReadValidInput.StartEqualToTotalSubtract1:
Assert.That(result.Start, Is.EqualTo(startFromParamValue), Enums.Message.START_ERROR);
break;
case ReadValidInput.ResourceId:
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
Assert.That(result.Items[0].ResourceId, Is.EqualTo(resourceId), $"resourceId {resourceId} does not match!");
break;
case ReadValidInput.Id:
Assert.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
Assert.That(result.Items[0].Id, Is.EqualTo(phaseId), $"phaseId {phaseId} does not match!");
break;
}
}
private void ReadAndVerifyData(Dictionary <string, object> parameters, ReadValidInput valueType, string fieldName, int fieldValue)
{
ReadResponseData <Partition> result = null;
int tempStart = 0;
if (ReadValidInput.RandomStart == valueType || ReadValidInput.StartEqualToTotalSubtract1 == valueType)
{
tempStart = GetTotalRecords(valueType);
parameters[fieldName] = tempStart;
}
result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Partition>(parameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, partition));
switch (valueType)
{
case ReadValidInput.NoParameter:
if (fieldName == PartitionApiFields.RequestType)
{
Assert.That(result.Count, Is.EqualTo(defaultCount), Enums.Message.COUNT_ERROR);
Assert.That(result.Start, Is.EqualTo(0), Enums.Message.START_ERROR);
}
if (fieldName == PartitionApiFields.Count)
{
Assert.That(result.Count, Is.EqualTo(defaultCount), Enums.Message.COUNT_ERROR);
}
if (fieldName == PartitionApiFields.Start)
{
Assert.That(result.Start, Is.EqualTo(defaultStart), Enums.Message.START_ERROR);
}
break;
case ReadValidInput.RequestType0:
Assert.That(result.Total, Is.EqualTo(1), Enums.Message.TOTAL_ERROR);
Assert.That(result.Items[0].DictionaryValues[$"{partition}.P_Id"], Is.EqualTo(AuthenticationInfoProvider.Current.DefaultPartition), $"{fieldName} doesnt match!");
break;
case ReadValidInput.RequestType1:
Assert.That(result.Total, Is.GreaterThan(1), Enums.Message.TOTAL_ERROR);
break;
case ReadValidInput.Count2:
Assert.That(result.Count, Is.EqualTo(2), Enums.Message.COUNT_ERROR);
Assert.That(result.Total, Is.EqualTo(2), Enums.Message.TOTAL_ERROR);
break;
case ReadValidInput.Count10:
Assert.That(result.Count, Is.EqualTo(defaultCount), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.RandomCount:
Assert.That(result.Count, Is.EqualTo(fieldValue), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.MaxCount:
Assert.That(result.Count, Is.EqualTo(fieldValue), Enums.Message.COUNT_ERROR);
Assert.That(result.Items.Count, Is.EqualTo(fieldValue), Enums.Message.COUNT_ERROR);
break;
case ReadValidInput.Start0:
Assert.That(result.Start, Is.EqualTo(fieldValue), Enums.Message.START_ERROR);
break;
case ReadValidInput.RandomStart:
case ReadValidInput.StartEqualToTotalSubtract1:
Assert.That(result.Start, Is.EqualTo(tempStart), Enums.Message.START_ERROR);
break;
}
}
