public void TestReadPhaseWithDuplicateParameters(string param, bool isDuplicatedValue)
{
Enums.ResourceType job = Enums.ResourceType.Job;
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
};
List <object> duplicatedParameters = new List <object>();
var parameterValues = new Dictionary <string, object>
{
[PhaseApiFields.ResourceId + "1"] = (int)records.Data[$"{job.ToPrivateEnum()}0"].Id,
[PhaseApiFields.ResourceId + "2"] = (int)records.Data[$"{job.ToPrivateEnum()}1"].Id,
[PhaseApiFields.Id + "1"] = PhaseHelper.CreatePhase(job, records.Data[$"{job.ToPrivateEnum()}0"].Id.ToString()),
[PhaseApiFields.Id + "2"] = PhaseHelper.CreatePhase(job, records.Data[$"{job.ToPrivateEnum()}1"].Id.ToString()),
[PhaseApiFields.Resource + "1"] = (int)Enums.ResourceType.Client,
[PhaseApiFields.Resource + "2"] = (int)Enums.ResourceType.Activity,
[PhaseApiFields.Count + "1"] = 10,
[PhaseApiFields.Count + "2"] = 11,
[PhaseApiFields.Start + "1"] = 10,
[PhaseApiFields.Start + "2"] = 12,
[PhaseApiFields.Field + "1"] = PhaseApiFields.Memo,
[PhaseApiFields.Field + "2"] = PhaseApiFields.Phase,
[PhaseApiFields.Condition + "1"] = $"{nameof(PhaseApiFields.Id)}:eq={records.Data[$"{job.ToPrivateEnum()}0"].Id}",
[PhaseApiFields.Condition + "2"] = $"{nameof(PhaseApiFields.Id)}:eq={records.Data[$"{job.ToPrivateEnum()}1"].Id}",
[PhaseApiFields.Order + "1"] = $"{PhaseApiFields.Order}={nameof(PhaseApiFields.Id)}:{records.Data[$"{job.ToPrivateEnum()}0"].Id}",
[PhaseApiFields.Order + "2"] = $"{PhaseApiFields.Order}={nameof(PhaseApiFields.Id)}:{records.Data[$"{job.ToPrivateEnum()}1"].Id}",
};
if (isDuplicatedValue)
{
duplicatedParameters = new List <object>
{
parameterValues[$"{param}1"],
parameterValues[$"{param}1"],
parameterValues[$"{param}1"],
};
}
else
{
duplicatedParameters = new List <object>
{
parameterValues[$"{param}1"],
parameterValues[$"{param}2"],
parameterValues[$"{param}2"],
};
}
if (param != PhaseApiFields.Resource)
{
parameters.Add(PhaseApiFields.Resource, (int)job);
}
parameters.Add(param, duplicatedParameters);
ErrorCode result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadFail <Phase>(parameters);
Assert.That(result, MustBe.MatchingErrorCode(Enums.PublicAPIResultCode.ParameterIsInvalid), Enums.Message.WRONG_ERROR_CODE);
}
private Dictionary <string, object> GetUrlParameters(ReadSpecialInvalidInput inputType)
{
Dictionary <string, object> result = new Dictionary <string, object>()
{
[PhaseApiFields.Partition] = AuthenticationInfoProvider.Current.DefaultPartition,
[PhaseApiFields.Resource] = (int)defaultResource,
};
long numberNotExist = 9000554554;
string phaseId = PhaseHelper.CreatePhase(defaultResource, records.Data[defaultResource.ToPrivateEnum() + "0"].Id.ToString());
switch (inputType)
{
case ReadSpecialInvalidInput.CountEquals0:
result[PhaseApiFields.Count] = 0;
break;
case ReadSpecialInvalidInput.CountOver200:
result[PhaseApiFields.Count] = 201;
break;
case ReadSpecialInvalidInput.MissingPartition:
result.Remove(PhaseApiFields.Partition);
break;
case ReadSpecialInvalidInput.MissingResource:
result.Remove(PhaseApiFields.Resource);
break;
case ReadSpecialInvalidInput.ResourceName:
result[PhaseApiFields.Resource] = defaultResource.ToLowerString();
break;
case ReadSpecialInvalidInput.StartEqualsTotal:
result[PhaseApiFields.Start] = total;
break;
case ReadSpecialInvalidInput.StartGreaterThanTotal:
result[PhaseApiFields.Start] = total + 1;
break;
case ReadSpecialInvalidInput.ResourceIdNotExist:
result[PhaseApiFields.ResourceId] = numberNotExist;
break;
case ReadSpecialInvalidInput.ResourceIdFromAnotherResource:
result[PhaseApiFields.ResourceId] = records.Data[Enums.ResourceType.Resume.ToPrivateEnum() + "0"].Id;
break;
case ReadSpecialInvalidInput.ResourceIdValidNumberInHex:
result[PhaseApiFields.ResourceId] = "0x" + records.Data[defaultResource.ToPrivateEnum() + "0"].Id.ToString("X");
break;
case ReadSpecialInvalidInput.ResourceIdInvalidNumberInHex:
result[PhaseApiFields.ResourceId] = "0x" + numberNotExist.ToString("X");
break;
case ReadSpecialInvalidInput.ResourceIdValidNumberInE:
result[PhaseApiFields.ResourceId] = Util.ToExponential(records.Data[defaultResource.ToPrivateEnum() + "0"].Id.ToString());
break;
case ReadSpecialInvalidInput.ResourceIdInvalidNumberInE:
result[PhaseApiFields.ResourceId] = Util.ToExponential(numberNotExist.ToString());
break;
case ReadSpecialInvalidInput.IdNotExist:
result[PhaseApiFields.Id] = numberNotExist;
break;
case ReadSpecialInvalidInput.IdValidNumberInHex:
result[PhaseApiFields.Id] = "0x" + int.Parse(phaseId).ToString("X");
break;
case ReadSpecialInvalidInput.IdInvalidNumberInHex:
result[PhaseApiFields.Id] = "0x" + numberNotExist.ToString("X");
break;
case ReadSpecialInvalidInput.IdValidNumberInE:
result[PhaseApiFields.Id] = Util.ToExponential(phaseId);
break;
case ReadSpecialInvalidInput.IdInvalidNumberInE:
result[PhaseApiFields.Id] = Util.ToExponential(numberNotExist.ToString());
break;
}
return(result);
}
/// <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;
}
}