public void CreateSingleCrossReferenceFieldMappingTest()
{
// Arrange.
const string ProcessName = "TestProcess";
var fieldName = ReflectionHelper.GetPropertyName<TestEditable>(x => x.CR);
const string ReferencedProcessName = "CRProcess";
var keyMapping = new FieldMappingDefinition
{
FieldName = ReflectionHelper.GetPropertyName<ReferenceEdit>(x => x.Field1),
ValueExpression = context => null,
IsKey = true,
};
var fieldMapping = new FieldMappingDefinition { FieldName = fieldName, ValueExpression = context => null, IsKey = true, Subfields = { keyMapping } };
var dtm = new Mock<IDynamicTypeManager>();
dtm.Setup(x => x.GetEditableRootType(ProcessName)).Returns(typeof(TestEditable));
dtm.Setup(x => x.GetEditableRootType(ReferencedProcessName)).Returns(typeof(ReferenceEdit));
var typeConverter = Mock.Create<ITypeConverter>(Behavior.Loose);
var runtimeDatabase = Mock.Create<IRuntimeDatabase>(Behavior.Loose);
var factory = new ProcessFieldMappingFactory { DynamicTypeManager = dtm.Object, TypeConverter = typeConverter, RuntimeDatabase = runtimeDatabase };
// Act.
var mapping = factory.CreateMapping(ProcessName, fieldMapping);
// Assert.
Assert.IsTrue(mapping is SingleCrossReferenceFieldMapping);
}
public void CreateComplexValueCalculatorTest()
{
// Arrange.
var typeConverter = Mock.Create<ITypeConverter>(Behavior.Loose);
var fieldMappingDefinition = new FieldMappingDefinition
{
FieldName = ReflectionHelper.GetFieldName<Employee>(x => x.FirstName),
ValueExpression = c => "First Name"
};
var propertyMappingDefinition = new FieldMappingDefinition
{
FieldName = ReflectionHelper.GetPropertyName<Employee>(x => x.LastName),
ValueExpression = c => "Last Name"
};
var mappingDefinition = new FieldMappingDefinition { FieldName = "TestField", Subfields = { fieldMappingDefinition, propertyMappingDefinition } };
var factory = new ValueCalculatorFactory(typeConverter);
// Act.
var valueCalculator = factory.CreateValueCalculator(typeof(Employee), mappingDefinition);
// Assert.
Assert.IsTrue(valueCalculator is ComplexValueCalculator);
}
public void CreateSimpleValueCalculatorTest()
{
// Arrange.
var typeConverter = Mock.Create<ITypeConverter>(Behavior.Loose);
var mappingDefinition = new FieldMappingDefinition { FieldName = "TestField", ValueExpression = c => null };
var factory = new ValueCalculatorFactory(typeConverter);
// Act.
var valueCalculator = factory.CreateValueCalculator(typeof(string), mappingDefinition);
// Assert.
Assert.IsTrue(valueCalculator is SimpleValueCalculator);
}
public void CreateArrayValueCalculatorTest()
{
// Arrange.
var typeConverter = Mock.Create<ITypeConverter>(Behavior.Loose);
var elementMappingDefinition = new FieldMappingDefinition { FieldName = Constants.ArrayItemGenericFieldName };
var mappingDefinition = new FieldMappingDefinition { FieldName = "TestField", Subfields = { elementMappingDefinition } };
var factory = new ValueCalculatorFactory(typeConverter);
// Act.
var valueCalculator = factory.CreateValueCalculator(typeof(string[]), mappingDefinition);
// Assert.
Assert.IsTrue(valueCalculator is ArrayValueCalculator);
}
/// <summary>
/// Create a <see cref="IValueCalculator"/> for the specified <see cref="FieldMappingDefinition"/>.
/// </summary>
/// <param name="type">
/// The <see cref="IValueCalculator"/> value type.
/// </param>
/// <param name="mappingDefinition">
/// The mapping definition.
/// </param>
/// <returns>
/// The <see cref="IValueCalculator"/>.
/// </returns>
public IValueCalculator CreateValueCalculator(Type type, FieldMappingDefinition mappingDefinition)
{
if (type == null)
throw new ArgumentNullException("type");
if (mappingDefinition == null)
throw new ArgumentNullException("mappingDefinition");
if (type.IsArray)
return CreateArrayValueCalculator(type, mappingDefinition);
if (IsSimpleType(type))
return CreateSimpleValueCalculator(type, mappingDefinition);
return CreateComplexValueCalculator(type, mappingDefinition);
}
/// <summary>
/// Creates a mapping.
/// </summary>
/// <param name="processName">
/// The process name.
/// </param>
/// <param name="mappingDefinition">
/// The mapping definition.
/// </param>
/// <returns>
/// The <see cref="IProcessFieldMapping"/>.
/// </returns>
public IProcessFieldMapping CreateMapping(string processName, FieldMappingDefinition mappingDefinition)
{
if (mappingDefinition == null)
throw new ArgumentNullException("mappingDefinition");
var editableRootType = DynamicTypeManager.GetEditableRootType(processName);
var property = editableRootType.GetPropertyByName(mappingDefinition.FieldName);
if (property == null)
throw new ArgumentException(
string.Format(
CultureInfo.InvariantCulture,
"Could not find field \"{0}\" in process \"{1}\".",
mappingDefinition.FieldName,
processName));
if (property.Name == Constants.CurrentStateColumnName)
return CreateSimpleFieldMapping(property, mappingDefinition);
var crAttribute = property.GetCustomAttribute<CrossRefFieldAttribute>();
if (crAttribute != null)
{
return !crAttribute.AllowMultiple
? (IProcessFieldMapping)
CreateSingleCrossReferenceFieldMapping(property, mappingDefinition)
: CreateMultiCrossReferenceFieldMapping(property, mappingDefinition);
}
var fileAttribute = property.GetCustomAttribute<FileProcessAttribute>();
if (fileAttribute != null)
{
return CreateFileFieldMapping(property, mappingDefinition);
}
var checklistAttribute = property.GetCustomAttribute<ChecklistFieldAttribute>();
if (checklistAttribute != null)
{
return CreateChecklistFieldMapping(property, mappingDefinition);
}
var fieldTypeAttribute = property.GetCustomAttribute<FieldTypeAttribute>();
if (fieldTypeAttribute != null && fieldTypeAttribute.ColumnType == ColumnTypes.Sample)
{
return CreateSampleFieldMapping(property, mappingDefinition);
}
return CreateSimpleFieldMapping(property, mappingDefinition);
}
public void CreateSimpleFieldMappingTest()
{
// Arrange.
const string ProcessName = "TestProcess";
var fieldName = ReflectionHelper.GetPropertyName<TestEditable>(x => x.Text);
var fieldMapping = new FieldMappingDefinition { FieldName = fieldName, IsKey = true, ValueExpression = context => null };
var dtm = new Mock<IDynamicTypeManager>();
dtm.Setup(x => x.GetEditableRootType(ProcessName)).Returns(typeof(TestEditable));
var typeConverter = Mock.Create<ITypeConverter>(Behavior.Loose);
var factory = new ProcessFieldMappingFactory { DynamicTypeManager = dtm.Object, TypeConverter = typeConverter };
// Act.
var mapping = factory.CreateMapping(ProcessName, fieldMapping);
// Assert.
Assert.IsTrue(mapping is SimpleFieldMapping);
}
private IValueCalculator CreateSimpleValueCalculator(Type type, FieldMappingDefinition mappingDefinition)
{
return new SimpleValueCalculator(mappingDefinition.ValueExpression, type, TypeConverter);
}
public void CreateSampleFieldMappingTest()
{
// Arrange.
const string ProcessName = "TestProcess";
var fieldName = ReflectionHelper.GetPropertyName<TestEditable>(x => x.Sample);
var valueMapping = new FieldMappingDefinition
{
FieldName = ReflectionHelper.GetPropertyName<ISampleEdit>(s => s.SampleNumeric),
ValueExpression = context => null
};
var fieldMapping = new FieldMappingDefinition { FieldName = fieldName, ValueExpression = context => null, Subfields = { valueMapping } };
var dtm = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
Mock.Arrange(() => dtm.GetEditableRootType(ProcessName)).Returns(typeof(TestEditable));
var typeConverter = Mock.Create<ITypeConverter>(Behavior.Loose);
var runtimeDatabase = Mock.Create<IRuntimeDatabase>(Behavior.Loose);
var factory = new ProcessFieldMappingFactory { DynamicTypeManager = dtm, TypeConverter = typeConverter, RuntimeDatabase = runtimeDatabase };
// Act.
var mapping = factory.CreateMapping(ProcessName, fieldMapping);
// Assert.
Assert.IsTrue(mapping is SampleFieldMapping);
}
private IPropertySetter CreatePropertySetter(Type targetType, FieldMappingDefinition mappingDefinition)
{
var propertyInfo = targetType.GetProperty(mappingDefinition.FieldName, BindingFlags.Instance | BindingFlags.Public);
if (propertyInfo != null)
{
return new PropertySetter(propertyInfo, CreateValueCalculator(propertyInfo.PropertyType, mappingDefinition));
}
var fieldInfo = targetType.GetField(mappingDefinition.FieldName, BindingFlags.Instance | BindingFlags.Public);
if (fieldInfo != null)
{
return new FieldSetter(fieldInfo, CreateValueCalculator(fieldInfo.FieldType, mappingDefinition));
}
throw new ArgumentException(
string.Format(
CultureInfo.InvariantCulture,
"Could not find the field or property \"{0}\" in type \"{1}\".",
mappingDefinition.FieldName,
targetType.AssemblyQualifiedName),
"mappingDefinition");
}
private SampleFieldMapping CreateSampleFieldMapping(PropertyInfo property, FieldMappingDefinition mappingDefinition)
{
return new SampleFieldMapping(
property,
mappingDefinition.ValueExpression,
mappingDefinition.Subfields.Select(CreateSampleValueMapping));
}
private ChecklistFieldMapping CreateChecklistFieldMapping(PropertyInfo property, FieldMappingDefinition mappingDefinition)
{
var checklistAttribute = property.GetCustomAttribute<ChecklistFieldAttribute>();
var childMappings = CreateChildMappings(checklistAttribute.AnswerProcessName, mappingDefinition);
return new ChecklistFieldMapping(property, mappingDefinition.ValueExpression, childMappings, DynamicTypeManager);
}
private FileFieldMapping CreateFileFieldMapping(PropertyInfo property, FieldMappingDefinition mappingDefinition)
{
MappingExpression nameExpression = null;
var nameMappingDefinition = mappingDefinition.Subfields.FirstOrDefault(m => m.FieldName == Constants.ExpressionDesignerFileNameFieldName);
if (nameMappingDefinition != null)
{
nameExpression = nameMappingDefinition.ValueExpression;
}
MappingExpression contentExpression = null;
var contentMappingDefinition = mappingDefinition.Subfields.FirstOrDefault(m => m.FieldName == Constants.ExpressionDesignerFileContentFieldName);
if (contentMappingDefinition != null)
{
contentExpression = contentMappingDefinition.ValueExpression;
}
MappingExpression locationExpression = null;
var locationMappingDefinition = mappingDefinition.Subfields.FirstOrDefault(m => m.FieldName == Constants.ExpressionDesignerFileLocationFieldName);
if (locationMappingDefinition != null)
{
locationExpression = locationMappingDefinition.ValueExpression;
}
return new FileFieldMapping(property, nameExpression, contentExpression, locationExpression, TypeConverter, FileManager);
}
private MultiCrossReferenceFieldMapping CreateMultiCrossReferenceFieldMapping(PropertyInfo property, FieldMappingDefinition mappingDefinition)
{
var crAttribute = property.GetCustomAttribute<CrossRefFieldAttribute>();
var childMappings = CreateChildMappings(crAttribute.ReferenceTableName, mappingDefinition);
return new MultiCrossReferenceFieldMapping(
property,
mappingDefinition.ValueExpression,
childMappings,
DynamicTypeManager,
RuntimeDatabase);
}
private SimpleFieldMapping CreateSimpleFieldMapping(PropertyInfo property, FieldMappingDefinition mappingDefinition)
{
return new SimpleFieldMapping(property, mappingDefinition.ValueExpression, mappingDefinition.IsKey, TypeConverter);
}
private IValueCalculator CreateComplexValueCalculator(Type type, FieldMappingDefinition mappingDefinition)
{
return new ComplexValueCalculator(type, mappingDefinition.Subfields.Select(m => CreatePropertySetter(type, m)));
}
private IValueCalculator CreateArrayValueCalculator(Type type, FieldMappingDefinition mappingDefinition)
{
var elementType = type.GetElementType();
IValueCalculator elementCalculator = null;
var elementMappingDefinition = mappingDefinition.Subfields.FirstOrDefault(m => m.FieldName == Constants.ArrayItemGenericFieldName);
if (elementMappingDefinition != null)
{
elementCalculator = CreateValueCalculator(elementType, elementMappingDefinition);
}
return new ArrayValueCalculator(elementType, mappingDefinition.ValueExpression, elementCalculator, TypeConverter);
}
private ISampleValueMapping CreateSampleValueMapping(FieldMappingDefinition mappingDefinition)
{
var property = typeof(ISampleEdit).GetProperty(mappingDefinition.FieldName);
if (property == null)
throw new ArgumentException(
string.Format(
CultureInfo.InvariantCulture,
"Could not find property \"{0}\" in type \"{1}\".",
mappingDefinition.FieldName,
typeof(ISampleEdit).AssemblyQualifiedName));
return new SampleValueMapping(property, mappingDefinition.ValueExpression, mappingDefinition.IsKey, TypeConverter);
}
private IEnumerable<IProcessFieldMapping> CreateChildMappings(string processName, FieldMappingDefinition mappingDefinition)
{
return mappingDefinition.Subfields.Select(subfield => CreateMapping(processName, subfield)).SortByExecutionOrder();
}
public void CreateFileFieldMappingTest()
{
// Arrange.
const string ProcessName = "TestProcess";
var nameMapping = new FieldMappingDefinition
{
FieldName = Constants.ExpressionDesignerFileNameFieldName,
ValueExpression = context => null,
IsKey = false
};
var contentMapping = new FieldMappingDefinition
{
FieldName = Constants.ExpressionDesignerFileContentFieldName,
ValueExpression = context => null,
IsKey = false
};
var locationMapping = new FieldMappingDefinition
{
FieldName = Constants.ExpressionDesignerFileLocationFieldName,
ValueExpression = context => null,
IsKey = false
};
var fileMapping = new FieldMappingDefinition
{
FieldName = ReflectionHelper.GetPropertyName<TestEditable>(x => x.File),
ValueExpression = null,
IsKey = false,
Subfields = { nameMapping, contentMapping, locationMapping }
};
var dtm = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
Mock.Arrange(() => dtm.GetEditableRootType(ProcessName)).Returns(typeof(TestEditable));
var typeConverter = Mock.Create<ITypeConverter>(Behavior.Loose);
var fileManager = Mock.Create<IFileManager>(Behavior.Loose);
var factory = new ProcessFieldMappingFactory { DynamicTypeManager = dtm, TypeConverter = typeConverter, FileManager = fileManager };
// Act.
var mapping = factory.CreateMapping(ProcessName, fileMapping);
// Assert.
Assert.IsTrue(mapping is FileFieldMapping);
}