public void TestReadContractConditionFull(string condition, object value)
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Parttion, AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", condition + value }
};
ReadResponseData <Contract> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Contract>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.InvalidParameterValue, result.Code, Enums.Message.INVALID_PARAMETER_VALUE);
}
public void TestReadContractMultipleConditionInvalidSaperator()
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Parttion, AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", string.Format("Contract.P_UpdateDate:gt={0}.Contract.P_UpdatedBy:ge=1", Util.ToString(DateTime.Now)) }
};
ReadResponseData <Contract> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Contract>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.InvalidParameterValue, result.Code, Enums.Message.INVALID_PARAMETER_VALUE);
}
public void TestReadContractConditionInvalidField()
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Parttion, AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", "Contract.P_RegistrationDatexxx:gt=" + Util.ToString(DateTime.Now) }
};
ReadResponseData <Contract> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Contract>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.InvalidParameterValue, result.Code, Enums.Message.INVALID_PARAMETER_VALUE);
}
public void TestReadContractStartMinus()
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Parttion, AuthenticationInfoProvider.Current.DefaultPartition },
{ "start", -1 }
};
ReadResponseData <Contract> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Contract>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.ValueLargerThanRange, result.Code, Enums.Message.EXCEEDS_RANGE_VALUE);
}
/// <summary>
/// Send a request to read resource. Parse response's xml to ReadResponseData.
/// </summary>
/// <param name="resourceType"></param>
/// <param name="urlParameters"></param>
/// <param name="fieldAlias"></param>
/// <param name="value"></param>
/// <returns>empty</returns>
private void ReadData <T>(Dictionary <string, object> urlParameters, string fieldAlias, decimal value) where T : XmlResource, new()
{
ReadResponseData <T> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <T>(urlParameters);
Assert.That(result.Code, Is.EqualTo(PublicAPIResultCode.Success), Enums.Message.WRONG_ERROR_CODE);
Assert.IsNotNull(result, string.Format(Enums.Message.READ_RESOURCE_FAILED, typeof(T).Name));
Assert.IsNotNull(result.Items, string.Format(Enums.Message.READ_RESOURCE_FAILED, typeof(T).Name));
Assert.That(result.Count, Is.EqualTo(1), Enums.Message.COUNT_ERROR);
Assert.That(result.Items.Count, Is.EqualTo(1), Enums.Message.COUNT_ERROR);
Assert.That(Convert.ToDecimal(result.Items[0].DictionaryValues[fieldAlias]), Is.EqualTo(value), "Value is not matched");
}
public void TestReadValidIdInput(Enums.ResourceType resourceType)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{SystemTypeField.Id}";
string id = records.Data[$"{resourceType.ToPrivateEnum()}0"].Id.ToString();
ReadResponseData <XmlResource> result = FieldHelper.ReadResource(resourceType, id, new List <string> {
fieldAlias
});
Assert.That(result.Items[0].DictionaryValues[fieldAlias].ToString(), Is.EqualTo(id), $"{fieldAlias} does not match!");
}
/// <summary>
/// Verify resources
/// </summary>
/// <param name="resourceType">Resource type</param>
private void ReadAndVerifyResource(Enums.ResourceType resourceType)
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ FieldApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ FieldApiFields.Resource, (int)resourceType },
};
ReadResponseData <Field> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Field>(parameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, "Field"));
Assert.That(result.Items.Select(item => item.DictionaryValues[$"{nameof(Field)}.{FieldApiFields.ResourceType}"].ToString()), Is.All.EqualTo(((int)resourceType).ToString()), $"Not all fields selected for resource {resourceType} have correct value in ResourceType property");
}
/// <summary>
/// Help Read and Verify Test Order
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="fieldsName">List of field name</param>
/// <param name="orderType">Enum Order type : Asc, Desc, MultiOrders, OrderEmpty</param>
/// <param name="smallestId">The smallest ID of this type of resource create by Private Fixture</param>
/// <param name="valueType">Type of the field need to be sorted</param>
public static void ReadPhaseAndVerify(Enums.ResourceType resourceType, List <string> fieldsName, OrderType orderType, string smallestId, Type valueType, int count)
{
string resourceName = nameof(Phase);
string idField = "Id";
Dictionary <string, Type> sortOrders = new Dictionary <string, Type>();
string order = string.Empty;
string field = string.Empty;
switch (orderType)
{
case OrderType.MultiOrders:
string fieldAlias1 = $"{fieldsName.First()}";
string fieldAlias2 = $"{fieldsName.Last()}";
order = $"{fieldAlias1}:{OrderType.Asc.ToLowerString()},{fieldAlias2}:{OrderType.Desc.ToLowerString()}";
field = $"{fieldAlias1},{fieldAlias2}";
sortOrders.Add($"{fieldAlias1}:{OrderType.Asc.ToLowerString()}", valueType);
sortOrders.Add($"{fieldAlias2}:{OrderType.Desc.ToLowerString()}", valueType);
break;
case OrderType.OrderEmpty:
order = field = $"{fieldsName.FirstOrDefault()}";
break;
default:
field = $"{fieldsName.FirstOrDefault()}";
order = $"{field}:{orderType.ToLowerString()}";
sortOrders.Add(order, valueType);
break;
}
Dictionary <string, object> urlParameter = new Dictionary <string, object>()
{
{ PartitionParameter, AuthenticationInfoProvider.Current.DefaultPartition },
{ OrderParameter, order },
{ FieldParameter, $"{idField},{field}" },
{ ConditionParameter, $"{idField}:ge={smallestId}" },
};
urlParameter.Add(ResourceParameter, (int)resourceType);
if (orderType == OrderType.OrderEmpty)
{
ReadOrderFailed(resourceName, urlParameter);
}
else
{
ReadResponseData <XmlResource> items = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess(resourceName, urlParameter);
Assert.That(items, MustBe.ReadSuccess(count), "Read resource failed!");
List <XmlResource> sortedItems = ResourceHelper.SortList(items.Items, sortOrders);
Assert.IsTrue(ResourceHelper.CompareList(items.Items, sortedItems, idField), Enums.Message.SORT_INCORRECT);
}
}
public void TestReadFieldCountGreaterThan200(Enums.ResourceType resource)
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Parttion, AuthenticationInfoProvider.Current.DefaultPartition },
{ "resource", (int)resource },
{ "count", 201 }
};
ReadResponseData <Field> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Field>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.ValueLargerThanRange, result.Code, Enums.Message.EXCEEDS_RANGE_VALUE);
}
public void TestReadFieldActive(object active, Enums.ResourceType resource)
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Parttion, AuthenticationInfoProvider.Current.DefaultPartition },
{ "resource", (int)resource },
{ "active", active }
};
ReadResponseData <Field> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Field>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.InvalidParameterValue, result.Code, Enums.Message.INVALID_PARAMETER_VALUE);
}
public void TestReadRecruiterMultipleConditionDateTime(string condition1, string condition2)
{
string datetime = Util.ToString(DateTime.Now);
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Parttion, AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", string.Format("{0}{1},{2}{3}", condition1, datetime, condition2, datetime) }
};
ReadResponseData <Recruiter> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Recruiter>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.InvalidParameterValue, result.Code, Enums.Message.INVALID_PARAMETER_VALUE);
}
public void TestReadActivityCountThan200()
{
var publicApiAdapter = PublicApiAdapter.CreateAdapterForDefaultConnection();
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ "count", 201 }
};
ReadResponseData <Activity> result = publicApiAdapter.ReadSuccess <Activity>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.ValueLargerThanRange, result.Code, Enums.Message.EXCEEDS_RANGE_VALUE);
}
public void TestReadAttachmentWithRegistedWriteScope(ApplicationType appType)
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, GetDefaultApplication(appType, false).Company.Partition },
{ "resource", (int)Enums.ResourceType.Client },
{ "requestType", 1 }
};
ReadResponseData <Attachment> result = GetDefaultWriteAdapter(appType).ReadSuccess <Attachment>(parameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.NotHavePermissionToResource), Enums.Message.WRONG_ERROR_CODE);
}
/// <summary>
/// Read and verify datetime field value by phase
/// </summary>
/// <param name="resourceName">Resource Name</param>
/// <param name="id">Resource Id</param>
/// <param name="fieldAlias">Field Alias</param>
/// <returns>empty</returns>
public static void ReadAndVerifyAutoDesignatedDateForPhase(Enums.ResourceType resourceType, string id, string fieldName)
{
string resourceName = resourceType.ToResourceName();
ReadResponseData <XmlResource> result = FieldHelper.ReadPhase(resourceType, id, new List <string> {
fieldName
});
Assume.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceName));
DateTime tempDate;
Assert.That(DateTime.TryParse(result.Items[0].DictionaryValues[fieldName].ToString(), out tempDate), ErrorMessage);
}
public void TestReadActivityKeywords(object value)
{
var publicApiAdapter = PublicApiAdapter.CreateAdapterForDefaultConnection();
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ "keywords", value }
};
ReadResponseData <Activity> result = publicApiAdapter.ReadSuccess <Activity>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.InvalidParameterValue, result.Code, Enums.Message.INVALID_PARAMETER_VALUE);
}
public void TestReadActivityMultipleConditionInvalidSaperator()
{
var publicApiAdapter = PublicApiAdapter.CreateAdapterForDefaultConnection();
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", string.Format("Activity.P_UpdateDate:gt={0}.Activity.P_UpdatedBy:ge=1", DateTime.Now.ToString("yyyy/MM/d 00:00:00")) }
};
ReadResponseData <Activity> result = publicApiAdapter.ReadSuccess <Activity>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.InvalidParameterValue, result.Code, Enums.Message.INVALID_PARAMETER_VALUE);
}
public void TestReadActivityConditionInvalidField()
{
var publicApiAdapter = PublicApiAdapter.CreateAdapterForDefaultConnection();
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ "condition", "Activity.P_RegistrationDatexxx:gt=" + DateTime.Now.ToString("yyyy/MM/d 00:00:00") }
};
ReadResponseData <Activity> result = publicApiAdapter.ReadSuccess <Activity>(parameters);
Assert.AreEqual(Enums.PublicAPIResultCode.InvalidParameterValue, result.Code, Enums.Message.INVALID_PARAMETER_VALUE);
}
private int GetTotalPhase(Enums.ResourceType defaultResource)
{
Dictionary <string, object> urlParameters = new Dictionary <string, object>()
{
[PhaseApiFields.Partition] = AuthenticationInfoProvider.Current.DefaultPartition,
[PhaseApiFields.Resource] = (int)defaultResource,
};
ReadResponseData <Phase> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Phase>(urlParameters);
Assume.That(result, MustBe.Not.Null, "The response data is null or cannot be parsed to ReadResponseData!");
return(result.Total);
}
public void TestReadValidIdInput(Enums.ResourceType resourceType, Enums.ResourceType referenceResourceType, string fieldName)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{fieldName}";
string id = records.Data[$"{referenceResourceType.ToPrivateEnum()}0"].Id.ToString();
ReadResponseData <XmlResource> result = FieldHelper.ReadReferenceResource(resourceType, id, fieldAlias);
Assert.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceName));
XmlResource referenceResource = result.Items[0].DictionaryValues[fieldAlias] as XmlResource;
Assert.That((referenceResource.DictionaryValues[referenceResourceType.ToString()] as XmlResource).DictionaryValues[$"{referenceResourceType.ToResourceName()}.P_Id"], Is.EqualTo(id), $"{fieldAlias} does not match!");
}
/// <summary>
/// Send a request to read resource. Parse response's xml to ReadResponseData.
/// </summary>
/// <param name="resourceType"></param>
/// <param name="urlParameters"></param>
/// <param name="fieldAlias"></param>
/// <param name="condition1"></param>
/// <param name="condition2"></param>
/// <param name="conditionValue1"></param>
/// <param name="conditionValue2"></param>
/// <returns>empty</returns>
private void ReadResourceAndVerify <T>(Dictionary <string, object> urlParameters, string fieldAlias1, string fieldAlias2, string condition1, string condition2, string conditionValue1, string conditionValue2) where T : XmlResource, new()
{
ReadResponseData <T> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <T>(urlParameters);
string condition = condition1 + condition2;
Assert.That(result.Code, Is.EqualTo(PublicAPIResultCode.Success), Enums.Message.WRONG_ERROR_CODE);
Assert.IsNotNull(result, string.Format(Enums.Message.READ_RESOURCE_FAILED, typeof(T).Name));
Assert.IsNotNull(result.Items, string.Format(Enums.Message.READ_RESOURCE_FAILED, typeof(T).Name));
Assert.Greater(result.Count, 0, Enums.Message.COUNT_ERROR);
Assert.Greater(result.Items.Count, 0, Enums.Message.COUNT_ERROR);
VerifyValue(result.Items, fieldAlias1, fieldAlias2, condition1, condition2, conditionValue1, conditionValue2);
}
public void TestReadValidUserInput(Enums.ResourceType resourceType, string fieldName)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{fieldName}";
string id = records.Data[$"{resourceType.ToPrivateEnum()}0"].Id.ToString();
ReadResponseData <XmlResource> result = FieldHelper.ReadResource(resourceType, id, new List <string> {
fieldAlias
});
XmlResource user = (result.Items[0].DictionaryValues[fieldAlias] as XmlResource).DictionaryValues["User"] as XmlResource;
Assert.That(user.DictionaryValues["User.P_Id"].ToString(), Is.EqualTo(DefaultUser), $"{fieldAlias} does not match!");
}
/// <summary>
/// Read and verify datetime field value by phase
/// </summary>
/// <param name="resourceName">Resource Name</param>
/// <param name="id">Resource Id</param>
/// <param name="fieldAlias">Field Alias</param>
/// <returns>empty</returns>
public static void ReadAndVerifyNoValidationDateForPhase(Enums.ResourceType resourceType, string id, string fieldAlias)
{
string resourceName = resourceType.ToResourceName();
string registrationDateAlias = SystemTypeField.RegistrationDate.Substring(2);
string updateDateAlias = SystemTypeField.UpdateDate.Substring(2);
ReadResponseData <XmlResource> result = FieldHelper.ReadPhase(resourceType, id, new List <string> {
registrationDateAlias, updateDateAlias
});
Assume.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, resourceName));
VerifyLessOrGreaterThanDateTime(result, fieldAlias, registrationDateAlias, updateDateAlias);
}
public void TestReadInvalidInput(Enums.ResourceType resourceType, string fieldName, ReadInvalidInput invalidInput)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = $"{resourceName}.{SystemTypeField.Id}";
string id = records.Data[$"{resourceType.ToPrivateEnum()}0"].Id.ToString();
id = string.Format(FieldValueMapperInvalidRead.InvalidInputMapper[invalidInput], id);
ReadResponseData <XmlResource> result = FieldHelper.ReadResource(resourceType, id, new List <string> {
fieldAlias
});
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.InvalidParameterValue), Enums.Message.WRONG_ERROR_CODE);
}
public void TestReadScopeAttachmentResourcesWithRegistedNoScope(ApplicationType appType)
{
InitPublicApiConnections(appType);
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ Partition, appInfo.Company.Partition },
{ "resource", (int)Enums.ResourceType.Client },
{ "requestType", 1 }
};
ReadResponseData <Attachment> result = adapter.ReadSuccess <Attachment>(parameters);
Assert.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.NotHavePermissionToResource), Enums.Message.WRONG_ERROR_CODE);
}
/// <summary>
/// Get a list of descendant Options
/// </summary>
/// <param name="alias">Option Alias: Option.P_Area, Option.P_Industry...</param>
/// <returns>List of Alias</returns>
public static List <string> GetOptionList(string alias)
{
List <string> result = new List <string>();
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ "partition", AuthenticationInfoProvider.Current.DefaultPartition },
{ "alias", alias },
{ "enabled", 1 },
{ "level", 2 }
};
ReadResponseData <Option> optionList = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Option>(parameters);
if (optionList != null && optionList.Items != null && optionList.Items.Count > 0)
{
Dictionary <string, Type> sortOrder = new Dictionary <string, Type>()
{
{ "Option.P_Order:asc", typeof(int) }
};
Option parent = optionList.Items.FirstOrDefault();
if (parent != null && parent.Items != null && parent.Items.Count > 0)
{
List <Option> parentList = new List <Option>();
foreach (Option option in parent.Items)
{
parentList.Add(option);
}
//Just sort the items level 1 in case of Phase Option
parentList = ResourceHelper.SortList(parentList, sortOrder);
foreach (Option option in parentList)
{
if (option.Items != null && option.Items.Count > 0)
{
foreach (Option child in option.Items)
{
result.Add(child.Alias);
}
}
else
{
result.Add(option.Alias);
}
}
}
}
else
{
Log.Info("Cannot read Option!");
}
return(result);
}
/// <summary>
/// Get list of phase
/// </summary>
/// <param name="resoureType">Resource type</param>
/// <param name="resourceId">Resource id</param>
/// <param name="fieldName">Field name</param>
/// <returns>List of Phase</returns>
public static List <Phase> GetValueField(Enums.ResourceType resoureType, string resourceId, List <string> fieldNames)
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ PhaseApiFields.Resource, (int)resoureType },
{ PhaseApiFields.ResourceId, resourceId },
{ PhaseApiFields.Field, string.Join(",", fieldNames) },
};
ReadResponseData <Phase> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Phase>(parameters);
Assume.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
return(result.Items);
}
//To-do: update this method when reading phase-entry fixture is done!
private string ReadPhaseBasedOnResource(Enums.ResourceType resourceType, int index)
{
Dictionary <string, object> urlParameters = new Dictionary <string, object>
{
[PhaseApiFields.Partition] = AuthenticationInfoProvider.Current.DefaultPartition,
[PhaseApiFields.Resource] = (int)resourceType,
[PhaseApiFields.ResourceId] = updatingRecords.Data[$"{resourceType.ToPrivateEnum()}{index}"].Id,
[PhaseApiFields.Field] = "Id"
};
ReadResponseData <Phase> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Phase>(urlParameters);
Assume.That(result, MustBe.ReadSuccess(1), "Cannot read the phase!");
return(result.Items.First().Id);
}
public void TestSearchCondition(string requestType)
{
Dictionary <string, object> urlParameters = new Dictionary <string, object>();
if (requestType != null)
{
urlParameters[PartitionApiFields.RequestType] = requestType;
}
PublicAPIConnection connection = new PublicAPIConnection(singleCompanyAppInfo.Key, singleCompanyAppInfo.Secret);
ReadResponseData <Partition> result = PublicApiAdapter.CreateAdapter(connection, singleCompanyAppInfo.Company.Partition).ReadSuccess <Partition>(urlParameters);
Assert.That(result, MustBe.ReadSuccess(1), string.Format(Enums.Message.READ_RESOURCE_FAILED, "Partition"));
}
/// <summary>
/// Get phase ids by resource id
/// </summary>
/// <param name="resourceType">Resource type</param>
/// <param name="resourceId">Resource id</param>
/// <returns>List of phase ids</returns>
public static List <string> GetPhaseIds(Enums.ResourceType resourceType, string resourceId)
{
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ PhaseApiFields.Partition, AuthenticationInfoProvider.Current.DefaultPartition },
{ PhaseApiFields.Resource, (int)resourceType },
{ PhaseApiFields.Condition, $"{nameof(PhaseApiFields.ResourceId)}:ge={resourceId}" },
{ PhaseApiFields.Field, $"{nameof(PhaseApiFields.Id)},{nameof(PhaseApiFields.ResourceId)},{nameof(PhaseApiFields.Resource)},{nameof(PhaseApiFields.Phase)},{nameof(PhaseApiFields.Recent)},{nameof(PhaseApiFields.RegistrationDate)},{nameof(PhaseApiFields.UpdateDate)},{nameof(PhaseApiFields.RegisteredBy)},{nameof(PhaseApiFields.UpdatedBy)}" },
};
ReadResponseData <Phase> result = PublicApiAdapter.CreateAdapterForDefaultConnection().ReadSuccess <Phase>(parameters);
Assume.That(result.Code, Is.EqualTo(Enums.PublicAPIResultCode.Success), string.Format(Enums.Message.READ_RESOURCE_FAILED, nameof(Phase)));
return(result.Items.Select(item => item.Id).ToList());
}
private void VerifyFieldsHaveProperActiveStatus(ReadResponseData <Field> result, IEnumerable <string> expectedAliases)
{
var actualData = result.Items.Select(item => item.Alias).ToList();
var expectedData = expectedAliases.ToList();
if (expectedData.Count <= MaxReadBatchSize)
{
Assert.That(actualData, Is.EquivalentTo(expectedData));
}
else
{
Assert.That(actualData, Is.SubsetOf(expectedData));
}
}
