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