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; } }