public void TestUpdateListItem(Enums.ResourceType resourceType, WriteInvalidInput valueType, int expectedCode)
{
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
return(ResourceHelper.CreateResourceInstance(records, resourceType, depKey));
});
List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList, cleaner);
Assume.That(ids, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assume.That(ids.Select(t => t.Code), Is.All.EqualTo(0), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
string resourceName = resourceType.ToResourceName();
string fieldAlias = resourceName + "." + AppField;
string fieldValue = FieldValueMapper.InvalidMapper[valueType];
resourceList = ids.Select(item =>
{
return(ResourceHelper.CreateUpdatedResource(resourceType, item.Id, fieldAlias, fieldValue));
});
ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList);
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.UPDATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(result.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestCreateSingleItem(Enums.ResourceType resourceType, WriteInvalidInput valueType, int expectedCode)
{
string fieldAlias = resourceType.ToResourceName() + "." + AppField;
XmlResource resource = ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, FieldValueMapper.InvalidMapper[valueType], records, true);
ErrorCode result = ResourceHelper.WriteResourceFail(resource, cleaner);
Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestCreateSingleItem(Enums.ResourceType resourceType, WriteInvalidInput valueType, int expectedCode)
{
Assume.That(customFields.Data, Is.Not.Null, "HrbcFieldCreator cannot create custom fields!");
string fieldAlias = customFields.Data[$"{resourceType}"].Field.ToAlias();
XmlResource resource = ResourceHelper.CreateSingleResourceItem(resourceType, fieldAlias, FieldValueMapper.InvalidMapper[valueType], records, true);
ErrorCode result = ResourceHelper.WriteResourceFail(resource, cleaner);
Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestCreateSingleItem(Enums.ResourceType resourceType, WriteInvalidInput valueType, int expectedCode)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = resourceName + "." + AppField;
string fieldValue = FieldValueMapper.InvalidMapper[valueType];
XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType);
resource.DictionaryValues[fieldAlias] = fieldValue;
var error = ResourceHelper.WriteResourceFail(resource, cleaner);
Assert.That(error, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(error.Code, Is.EqualTo(expectedCode), string.Format(Enums.Message.WRONG_ERROR_CODE, resourceType));
}
public void TestCreateSingleItem(Enums.ResourceType resourceType, WriteInvalidInput valueType, int expectedCode)
{
Assume.That(customFields.Data, Is.Not.Null, "HrbcFieldCreator cannot create custom fields!");
string fieldAlias = customFields.Data[$"{resourceType}"].Field.ToAlias();
string fieldValue = FieldValueMapper.InvalidMapper[valueType];
XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType);
resource.DictionaryValues[fieldAlias] = fieldValue;
var error = ResourceHelper.WriteResourceFail(resource, cleaner);
Assert.That(error, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(error.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestUpdateSingleItem(Enums.ResourceType resourceType, WriteInvalidInput valueType, int expectedCode)
{
//Prepare data
XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType);
string id = ResourceHelper.WriteResource(resource, cleaner);
Assume.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
string fieldAlias = resourceType.ToResourceName() + "." + AppField;
resource = ResourceHelper.CreateUpdatedResource(resourceType, id, fieldAlias, FieldValueMapper.InvalidMapper[valueType], true);
//Write data
var error = ResourceHelper.WriteResourceFail(resource, null);
//Verify the result
Assert.That(error, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestCreateListItem(Enums.ResourceType resourceType, WriteInvalidInput valueType, int expectedCode)
{
Assume.That(customFields.Data, Is.Not.Null, "HrbcFieldCreator cannot create custom fields!");
string fieldAlias = customFields.Data[$"{resourceType}"].Field.ToAlias();
string fieldValue = FieldValueMapper.InvalidMapper[valueType];
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
var resource = ResourceHelper.CreateResourceInstance(records, resourceType, depKey);
resource.DictionaryValues[fieldAlias] = fieldValue;
return(resource);
}).ToList();
ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList, cleaner);
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.UPDATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(result.Code, Is.EqualTo(expectedCode), string.Format(Enums.Message.WRONG_ERROR_CODE, resourceType));
}
public void TestCreateListItem(Enums.ResourceType resourceType, WriteInvalidInput valueType, int expectedCode)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = resourceName + "." + AppField;
string fieldValue = FieldValueMapper.InvalidMapper[valueType];
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
var resource = ResourceHelper.CreateResourceInstance(records, resourceType, depKey);
resource.DictionaryValues[fieldAlias] = fieldValue;
return(resource);
}).ToList();
ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList, cleaner);
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.UPDATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(result.Code, Is.EqualTo(expectedCode), string.Format(Enums.Message.WRONG_ERROR_CODE, resourceType));
}
public void TestUpdateListItem(Enums.ResourceType resourceType, WriteInvalidInput valueType, int expectedCode)
{
//Prepare data 1
var resourceList = new[] { 0, 1 }.Select(depKey => ResourceHelper.CreateResourceInstance(records, resourceType, depKey));
List <WriteResultItem> ids = ResourceHelper.WriteResources(resourceType, resourceList, cleaner);
Assume.That(ids, MustBe.SuccessfullyWritten(resourceList.Count()), string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
//Prepare data 2
string fieldAlias = resourceType.ToResourceName() + "." + AppField;
resourceList = ids.Select(item => ResourceHelper.CreateUpdatedResource(resourceType, item.Id, fieldAlias, FieldValueMapper.InvalidMapper[valueType], true));
//Write data
ErrorCode result = ResourceHelper.WriteResourcesFail(resourceList);
//Verify the result
Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestUpdateSingleItem(Enums.ResourceType resourceType, WriteInvalidInput valueType, int expectedCode)
{
XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType);
string id = ResourceHelper.WriteResource(resource, cleaner);
Assume.That(id, Is.Not.Null.And.Not.Empty, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, Enums.ResourceType.Activity));
string resourceName = resourceType.ToResourceName();
string fieldAlias = resourceName + "." + AppField;
string fieldValue = FieldValueMapper.InvalidMapper[valueType];
resource = ResourceHelper.CreateUpdatedResource(resourceType, id, fieldAlias, fieldValue);
var error = ResourceHelper.WriteResourceFail(resource, null);
Assert.That(error, Is.Not.Null, string.Format(Enums.Message.UPDATE_RESOURCE_ENTRY_FAILED, Enums.ResourceType.Activity));
Assert.That(error.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestCreateSingleItem(Enums.ResourceType resourceType, string fieldName, WriteInvalidInput valueType, int expectedCode)
{
string fieldValue = FieldValueMapper.InvalidMapper[valueType];
Phase phase = PhaseHelper.CreatePhaseInstance(creatingRecords, resourceType);
phase.DictionaryValues[fieldName] = fieldValue;
var error = PhaseHelper.WritePhaseFail(phase);
Assert.That(error, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(error.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
private string GetFieldValue(Enums.ResourceType resourceType, string fieldName, WriteInvalidInput valueType, int index = 0)
{
string valueFormat = FieldValueMapper.InvalidInputMapper[valueType];
if (fieldName == SystemTypeField.Id)
{
return(string.Format(valueFormat, records.Data[$"{resourceType.ToPrivateEnum()}{index}"].Id));
}
return(string.Format(valueFormat, ResourceHelper.DefaultUser));
}
public void TestCreateSingleItem(Enums.ResourceType resourceType, string fieldName, WriteInvalidInput valueType, int expectedCode)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = resourceName + "." + fieldName;
string fieldValue = FieldValueMapper.InvalidMapper[valueType];
XmlResource resource = ResourceHelper.CreateResourceInstance(records, resourceType);
resource.DictionaryValues[fieldAlias] = fieldValue;
if (fieldName == ResourceHelper.PhaseDateField)
{
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()
};
}
var error = ResourceHelper.WriteResourceFail(resource, cleaner);
Assert.That(error, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(error.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestCreateSingleItem(Enums.ResourceType resourceType, string fieldName, WriteInvalidInput valueType, int expectedCode)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = resourceName + "." + fieldName;
string fieldValue = FieldValueMapper.InvalidInputMapper[valueType];
WriteInvalidHelper.CreateSingleItem(resourceType, fieldAlias, fieldValue,
expectedCode, cleaner, referenceRecords, true);
}
public void TestUpdateSingleItem(Enums.ResourceType resourceType, string fieldName, WriteInvalidInput valueType, int expectedCode)
{
string resourceName = resourceType.ToResourceName();
string fieldAlias = resourceName + "." + fieldName;
WriteInvalidHelper.UpdateSingleItem(resourceType, fieldAlias, (index) => GetInvalidFieldValue(resourceType, fieldName, valueType, index),
expectedCode, records, true, 0, referenceRecords);
}
private object GetInvalidFieldValue(Enums.ResourceType resourceType, string fieldName, WriteInvalidInput valueType, int index = 0)
{
Enums.ResourceType referenceResource = SystemTypeField.FieldResourceTypeMapper[fieldName];
switch (valueType)
{
case WriteInvalidInput.BigId: return("999999999999999999999999999999999999999999999");
case WriteInvalidInput.DeletedResourceId:
return(deletedRecords.Data[$"{referenceResource.ToPrivateEnum()}{index}"].Id.ToString());
case WriteInvalidInput.ExtraXmlTag:
XmlResource resource = new XmlResource();
resource.DictionaryValues[$"{referenceResource.ToResourceName()}.P_Id"] =
referenceRecords.Data[$"{referenceResource.ToPrivateEnum()}{index}"].Id.ToString();
return(resource);
case WriteInvalidInput.NegativeId: return("-" + referenceRecords.Data[$"{referenceResource.ToPrivateEnum()}{index}"].Id.ToString());
case WriteInvalidInput.NonNumeric: return("asdfkdjf ds");
case WriteInvalidInput.NotExistingResourceId: return("123213435345");
case WriteInvalidInput.SpecialCharacters: return("!@#$$#%%^&^&32");
case WriteInvalidInput.SQLInjection: return(InjectionInputData.SQLInjection);
case WriteInvalidInput.StartWithPlusSign: return("+" + referenceRecords.Data[$"{referenceResource.ToPrivateEnum()}{index}"].Id.ToString());
case WriteInvalidInput.StartWithSpace: return(" " + referenceRecords.Data[$"{referenceResource.ToPrivateEnum()}{index}"].Id.ToString());
case WriteInvalidInput.StartWithZero: return("0" + referenceRecords.Data[$"{referenceResource.ToPrivateEnum()}{index}"].Id.ToString());
//case WriteInvalidInput.WrongResourceType:
// return (referenceResource == Enums.ResourceType.Client)?
// referenceRecords.Data[$"{ResourceId.Person}{index}"].Id.ToString() : referenceRecords.Data[$"{ResourceId.Client}{index}"].Id.ToString();
}
return(null);
}
public void TestUpdateListItem(Enums.ResourceType resourceType, string fieldName, WriteInvalidInput valueType, int expectedCode)
{
string fieldValue = FieldValueMapper.InvalidMapper[valueType];
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
var phase = new Phase {
Id = ReadPhaseBasedOnResource(resourceType, depKey)
};
phase.DictionaryValues[fieldName] = fieldValue;
return(phase);
});
ErrorCode result = PhaseHelper.WritePhasesFail(resourceList);
Assert.That(result, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestCreateListItem(Enums.ResourceType resourceType, string fieldName, WriteInvalidInput valueType, int expectedCode)
{
string fieldValue = FieldValueMapper.InvalidMapper[valueType];
var resourceList = new[] { 0, 1 }.Select(depKey =>
{
var phase = PhaseHelper.CreatePhaseInstance(creatingRecords, resourceType, depKey);
phase.DictionaryValues[fieldName] = fieldValue;
return(phase);
}).ToList();
ErrorCode result = PhaseHelper.WritePhasesFail(resourceList);
Assert.That(result, Is.Not.Null, string.Format(Enums.Message.CREATE_RESOURCE_ENTRY_FAILED, resourceType));
Assert.That(result.Code, Is.EqualTo(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
public void TestUpdateSingleItem(Enums.ResourceType resourceType, string fieldName, WriteInvalidInput valueType, int expectedCode)
{
string fieldValue = FieldValueMapper.InvalidMapper[valueType];
var phase = new Phase {
Id = ReadPhaseBasedOnResource(resourceType, 0)
};
phase.DictionaryValues[fieldName] = fieldValue;
var error = PhaseHelper.WritePhaseFail(phase);
Assert.That(error, MustBe.MatchingErrorCode(expectedCode), Enums.Message.WRONG_ERROR_CODE);
}
