public void InitializeTest()
{
// Arrange.
const string ProcessName = "TestProcess";
var dtm = Mock.Create<IDynamicTypeManager>();
Mock.Arrange(() => dtm.GetEditableRootType(ProcessName)).Returns(typeof(TestEdit));
var mapping = new DataTriggerFieldMapping(TestsHelper.ExtractPropertyName(() => new TestEdit().Text), true, (s, d) => null);
var updater = new SimpleFieldUpdater { DynamicTypeManager = dtm };
// Act.
updater.Initialize(ProcessName, mapping);
// Assert.
Assert.AreEqual(TestsHelper.ExtractPropertyName(() => new TestEdit().Text), updater.FieldName);
Assert.IsTrue(updater.IsKey);
Assert.AreSame(mapping.ValueCalculator, updater.ValueCalculator);
Assert.AreSame(typeof(string), updater.PropertyType);
// Exceptions.
var invalidMapping1 = new DataTriggerFieldMapping("InvalidField", false, (s, d) => null);
var invalidMapping2 = new DataTriggerFieldMapping(TestsHelper.ExtractPropertyName(() => new TestEdit().ReadOnly), false, (s, d) => null);
TestsHelper.VerifyThrow<ArgumentNullException>(() => updater.Initialize(ProcessName, null));
TestsHelper.VerifyThrow<InvalidOperationException>(() => updater.Initialize(ProcessName, invalidMapping1));
TestsHelper.VerifyThrow<InvalidOperationException>(() => updater.Initialize(ProcessName, invalidMapping2));
}
public void InitializeLocalizedFieldTest()
{
// Arrange.
const string ProcessName = "TestProcess";
var dtm = Mock.Create<IDynamicTypeManager>();
Mock.Arrange(() => dtm.GetEditableRootType(ProcessName)).Returns(typeof(TestEdit));
var mapping = new DataTriggerFieldMapping(TestsHelper.ExtractPropertyName(() => new TestEdit().Localized), true, (s, d) => null);
var updater = new SimpleFieldUpdater { DynamicTypeManager = dtm };
// Act.
updater.Initialize(ProcessName, mapping);
// Assert.
Assert.AreEqual(TestsHelper.ExtractPropertyName(() => new TestEdit().Localized), updater.FieldName);
Assert.IsTrue(updater.IsKey);
Assert.AreSame(mapping.ValueCalculator, updater.ValueCalculator);
Assert.AreSame(typeof(string), updater.PropertyType);
Assert.IsTrue(updater.AllowLocalizedData);
Assert.AreEqual(3, updater.SupportedLocalizations.Count);
Assert.IsTrue(updater.SupportedLocalizations.Any(l => Equals(l.CultureName, "en-US")));
Assert.IsTrue(updater.SupportedLocalizations.Any(l => Equals(l.CultureName, "es-ES")));
Assert.IsTrue(updater.SupportedLocalizations.Any(l => Equals(l.CultureName, "fr-FR")));
}
public void ConstructorTest()
{
// Arrange.
const string DestinationField = "DestinationField";
const DataTriggerModificationType ModificationType = DataTriggerModificationType.Update;
var field1 = new DataTriggerFieldMapping("Test1", false, (s, d) => null);
var field2 = new DataTriggerFieldMapping("Test2", false, (s, d) => null);
var dataSources = new[]
{
new FieldMappingDataSourceDefinition("ds 1", "Process1", "Prop1.Prop2", true, true, true),
new FieldMappingDataSourceDefinition("ds 2", "Process2", "Prop3", false, false, false),
};
// Act.
var mapping = new DataTriggerListFieldMapping(dataSources, DestinationField, ModificationType, new List<DataTriggerFieldMapping> { field1, field2 });
// Assert.
Assert.AreEqual(2, mapping.DataSources.Count);
Assert.AreSame(dataSources[0], mapping.DataSources.ElementAt(0));
Assert.AreSame(dataSources[1], mapping.DataSources.ElementAt(1));
Assert.AreEqual(DestinationField, mapping.DestinationFieldName);
Assert.AreEqual(ModificationType, mapping.ModificationType);
Assert.IsTrue(new[] { field1, field2 }.SequenceEqual(mapping.Fields));
Assert.IsTrue(mapping.Fields.IsReadOnly);
}
/// <summary>
/// Creates a field updater from field mapping definition.
/// </summary>
/// <param name="processName">The destination process name.</param>
/// <param name="fieldMapping">The field mapping definition.</param>
/// <returns>Returns a field updater.</returns>
public IFieldUpdater CreateFieldUpdater(string processName, DataTriggerFieldMapping fieldMapping)
{
var type = DynamicTypeManager.GetEditableRootType(processName);
if (fieldMapping == null)
throw new ArgumentNullException("fieldMapping");
var property = type.GetPropertyByName(fieldMapping.FieldName);
if (property == null)
throw new InvalidOperationException(
string.Format(CultureInfo.InvariantCulture, "Destination field \"{0}\" not found.", fieldMapping.FieldName));
if (property.Name == Constants.CurrentStateColumnName)
return CreateSimpleFieldUpdater(processName, fieldMapping);
var fileAttribute = property.GetCustomAttribute<FileProcessAttribute>();
if (fileAttribute != null)
return CreateFileFieldUpdater(processName, fieldMapping);
var crAttribute = property.GetCustomAttribute<CrossRefFieldAttribute>();
if (crAttribute != null && !crAttribute.AllowMultiple)
return CreateSingleCrossReferenceFieldUpdater(processName, fieldMapping);
var fieldTypeAttribute = property.GetCustomAttribute<FieldTypeAttribute>();
if (fieldTypeAttribute != null && fieldTypeAttribute.ColumnType == ColumnTypes.Sample)
return CreateSampleFieldUpdater(processName, fieldMapping);
return CreateSimpleFieldUpdater(processName, fieldMapping);
}
public void InitializeTest()
{
// Arrange.
const string ProcessName = "TestProcess";
const string TriggerName = "Test Trigger";
var triggerGuid = new Guid("{A05F4E80-E1C6-4115-8582-0A823081BB19}");
const string ProcessToModify = "DestinationProcess";
const string FilterDefinition = "Test Filter";
const DataTriggerModificationType ModificationType = DataTriggerModificationType.Update;
var fieldMapping1 = new DataTriggerFieldMapping("Field1", false, (s, d) => null);
var fieldMapping2 = new DataTriggerFieldMapping("Field2", false, (s, d) => null);
var listMapping1 = new DataTriggerListFieldMapping(
Enumerable.Empty<FieldMappingDataSourceDefinition>(),
"Field3",
DataTriggerModificationType.Insert,
Enumerable.Empty<DataTriggerFieldMapping>());
var listMapping2 = new DataTriggerListFieldMapping(
Enumerable.Empty<FieldMappingDataSourceDefinition>(),
"Field4",
DataTriggerModificationType.Insert,
Enumerable.Empty<DataTriggerFieldMapping>());
var triggerMap = new DataTriggerMap(new[] { fieldMapping1, fieldMapping2 }, new[] { listMapping1, listMapping2 });
var triggerDefinition = new DataTriggerDefinition(TriggerName, triggerGuid, ProcessToModify, FilterDefinition, ModificationType, Enumerable.Empty<IActionRule>(), triggerMap);
var fieldUpdater1 = Mock.Create<IFieldUpdater>();
var fieldUpdater2 = Mock.Create<IFieldUpdater>();
var fieldUpdaterFactory = Mock.Create<IFieldUpdaterFactory>();
Mock.Arrange(() => fieldUpdaterFactory.CreateFieldUpdater(ProcessToModify, fieldMapping1)).Returns(fieldUpdater1);
Mock.Arrange(() => fieldUpdaterFactory.CreateFieldUpdater(ProcessToModify, fieldMapping2)).Returns(fieldUpdater2);
var listUpdater1 = Mock.Create<IListFieldUpdater>();
var listUpdater2 = Mock.Create<IListFieldUpdater>();
var listUpdaterFactory = Mock.Create<IListFieldUpdaterFactory>();
Mock.Arrange(() => listUpdaterFactory.CreateFieldUpdater(ProcessToModify, listMapping1)).Returns(listUpdater1);
Mock.Arrange(() => listUpdaterFactory.CreateFieldUpdater(ProcessToModify, listMapping2)).Returns(listUpdater2);
var trigger = new DataTrigger { FieldUpdaterFactory = fieldUpdaterFactory, ListFieldUpdaterFactory = listUpdaterFactory };
// Act.
trigger.Initialize(ProcessName, triggerDefinition);
// Assert.
Assert.AreEqual(TriggerName, trigger.Name);
Assert.AreEqual(triggerGuid, trigger.Guid);
Assert.AreEqual(ModificationType, trigger.ModificationType);
Assert.AreEqual(ProcessToModify, trigger.DestinationProcess);
Assert.AreEqual(FilterDefinition, trigger.FilterDefinition);
Assert.AreEqual(2, trigger.FieldUpdaters.Count);
Assert.IsTrue(trigger.FieldUpdaters.Contains(fieldUpdater1));
Assert.IsTrue(trigger.FieldUpdaters.Contains(fieldUpdater2));
Assert.AreEqual(2, trigger.ListFieldUpdaters.Count);
Assert.IsTrue(trigger.ListFieldUpdaters.Contains(listUpdater1));
Assert.IsTrue(trigger.ListFieldUpdaters.Contains(listUpdater2));
}
/// <summary>
/// Initializes the field updater properties.
/// </summary>
/// <param name="processName">
/// The process name.
/// </param>
/// <param name="fieldMapping">
/// The field mapping.
/// </param>
public void Initialize(string processName, DataTriggerFieldMapping fieldMapping)
{
var editType = DynamicTypeManager.GetEditableRootType(processName);
if (fieldMapping == null)
throw new ArgumentNullException("fieldMapping");
var property = editType.GetPropertyByName(fieldMapping.FieldName);
if (property == null)
throw new ArgumentException(
string.Format(
CultureInfo.InvariantCulture,
"Could not find the property \"{0}\" in type \"{1}\".",
fieldMapping.FieldName,
editType.AssemblyQualifiedName),
"fieldMapping");
var crAttribute = property.GetCustomAttribute<CrossRefFieldAttribute>();
if (crAttribute == null || crAttribute.AllowMultiple)
throw new ArgumentException(
string.Format(
CultureInfo.InvariantCulture,
"The property \"{0}\" in type \"{1}\" is not a single cross-reference.",
fieldMapping.FieldName,
editType.AssemblyQualifiedName),
"fieldMapping");
FieldName = property.Name;
IsKey = fieldMapping.IsKey;
ValueCalculator = fieldMapping.ValueCalculator;
ReferencedProcessName = crAttribute.ReferenceTableName;
var sampleFieldUpdaters = new List<IFieldUpdater>();
ChildMappings.Clear();
foreach (var childMappingDefinition in fieldMapping.ChildMappings)
{
var childMapping = FieldUpdaterFactory.CreateFieldUpdater(ReferencedProcessName, childMappingDefinition);
if (childMapping is SampleFieldUpdater)
{
// Sample field updaters should execute after SampleType, SampleSize and SamplingTechnique were updated, therefore we'll add them at the end.
sampleFieldUpdaters.Add(childMapping);
}
else
{
ChildMappings.Add(childMapping);
}
}
ChildMappings.AddRange(sampleFieldUpdaters);
}
/// <summary>
/// Initializes the field updater.
/// </summary>
/// <param name="processName">
/// The process name.
/// </param>
/// <param name="fieldMapping">
/// The field mapping.
/// </param>
public void Initialize(string processName, DataTriggerFieldMapping fieldMapping)
{
var type = DynamicTypeManager.GetEditableRootType(processName);
if (fieldMapping == null)
throw new ArgumentNullException("fieldMapping");
var property = type.GetPropertyByName(fieldMapping.FieldName);
if (property == null)
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" not found.", fieldMapping.FieldName));
if (!typeof(ISampleList).IsAssignableFrom(property.PropertyType))
throw new InvalidOperationException("Destination field is not a file.");
FieldName = property.Name;
ValueCalculator = fieldMapping.ValueCalculator;
}
public void InitializeTest()
{
// Arrange.
const string ProcessName = "TestProcess";
var dtm = Mock.Create<IDynamicTypeManager>();
Mock.Arrange(() => dtm.GetEditableRootType(ProcessName)).Returns(typeof(TestEdit));
var childMapping = new DataTriggerFieldMapping("FirstName", false, (data, root) => null);
var mapping = new DataTriggerFieldMapping(
ReflectionHelper.GetPropertyName<TestEdit>(x => x.Person),
true,
(s, d) => null,
new[] { childMapping });
var childUpdater = Mock.Create<IFieldUpdater>(Behavior.Loose);
var updaterFactory = Mock.Create<IFieldUpdaterFactory>(Behavior.Loose);
Mock.Arrange(() => updaterFactory.CreateFieldUpdater(Constants.BasePersonProcessName, childMapping)).Returns(childUpdater);
var updater = new SingleCrossReferenceFieldUpdater { DynamicTypeManager = dtm, FieldUpdaterFactory = updaterFactory };
// Act.
updater.Initialize(ProcessName, mapping);
// Assert.
Assert.AreEqual(ReflectionHelper.GetPropertyName<TestEdit>(x => x.Person), updater.FieldName);
Assert.IsTrue(updater.IsKey);
Assert.AreSame(mapping.ValueCalculator, updater.ValueCalculator);
Assert.AreEqual(Constants.BasePersonProcessName, updater.ReferencedProcessName);
Assert.AreEqual(1, updater.ChildMappings.Count);
Assert.IsTrue(updater.ChildMappings.Contains(childUpdater));
// Exceptions.
var invalidMapping1 = new DataTriggerFieldMapping("InvalidField", false, (data, root) => null);
var invalidMapping2 = new DataTriggerFieldMapping(
ReflectionHelper.GetPropertyName<TestEdit>(x => x.PersonList),
false,
(data, root) => null);
TestsHelper.VerifyThrow<ArgumentNullException>(() => updater.Initialize(ProcessName, null));
TestsHelper.VerifyThrow<ArgumentException>(() => updater.Initialize(ProcessName, invalidMapping1));
TestsHelper.VerifyThrow<ArgumentException>(() => updater.Initialize(ProcessName, invalidMapping2));
}
public void InitializeTest()
{
// Arrange.
const string ProcessName = "TestProcess";
var dtm = Mock.Create<IDynamicTypeManager>();
Mock.Arrange(() => dtm.GetEditableRootType(ProcessName)).Returns(typeof(TestEdit));
var mapping = new DataTriggerFieldMapping(TestsHelper.ExtractPropertyName(() => new TestEdit().File), false, (s, d) => null);
var updater = new FileFieldUpdater { DynamicTypeManager = dtm };
// Act.
updater.Initialize(ProcessName, mapping);
// Assert.
Assert.AreEqual(TestsHelper.ExtractPropertyName(() => new TestEdit().File), updater.FieldName);
Assert.AreSame(mapping.ValueCalculator, updater.ValueCalculator);
}
/// <summary>
/// Initializes the updater using a field mapping definition.
/// </summary>
/// <param name="processName">The process name.</param>
/// <param name="fieldMapping">The field mapping definition.</param>
public void Initialize(string processName, DataTriggerFieldMapping fieldMapping)
{
var type = DynamicTypeManager.GetEditableRootType(processName);
if (fieldMapping == null)
throw new ArgumentNullException("fieldMapping");
var property = type.GetPropertyByName(fieldMapping.FieldName);
if (property == null)
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" not found.", fieldMapping.FieldName));
if (!typeof(IFileProcess).IsAssignableFrom(property.PropertyType))
throw new InvalidOperationException("Destination field is not a file.");
var fileAttribute = property.GetCustomAttributes(typeof(FileProcessAttribute), false).OfType<FileProcessAttribute>().FirstOrDefault();
if (fileAttribute == null)
throw new InvalidOperationException("Invalid field type.");
FieldName = property.Name;
ValueCalculator = fieldMapping.ValueCalculator;
}
public void UpdateCanInsertItems()
{
// Arrange.
const string ProcessName = "TestProcess";
const string DestinationFieldName = "TestField";
const string ReferencedProcessName = "RefProcess";
const string FieldName1 = "Field1";
const string FieldName2 = "Field2";
var dataSourceDefinition = new FieldMappingDataSourceDefinition("Test Data Source", ProcessName, "TestProperty", true, true, true);
var fieldMapping1 = new DataTriggerFieldMapping(FieldName1, true, (s, d) => null);
var fieldMapping2 = new DataTriggerFieldMapping(FieldName2, false, (s, d) => null);
var mapping = new DataTriggerListFieldMapping(new[] { dataSourceDefinition }, DestinationFieldName, DataTriggerModificationType.Insert, new[] { fieldMapping1, fieldMapping2 });
var dtm = Mock.Create<IDynamicTypeManager>();
Mock.Arrange(() => dtm.GetEditableRootType(ProcessName)).Returns(typeof(DestinationEdit));
var item = Mock.Create<IEditableRoot>();
var sourceData1 = new DataTriggerSourceData();
var sourceData2 = new DataTriggerSourceData();
var sourceDataRetriever = Mock.Create<IFieldMappingSourceDataRetriever>();
Mock.Arrange(() => sourceDataRetriever.GetSourceData(item, null)).Returns(() => new[] { sourceData1, sourceData2 });
var savedDestinationItem1 = Mock.Create<IEditableRoot>();
Mock.Arrange(() => savedDestinationItem1.Id).Returns(111);
var newDestinationItem1 = Mock.Create<IEditableRootStub>();
var savableDestinationItem1 = newDestinationItem1 as ISavable;
Mock.Arrange(() => savableDestinationItem1.Save()).Returns(savedDestinationItem1);
var savedDestinationItem2 = Mock.Create<IEditableRoot>();
Mock.Arrange(() => savedDestinationItem2.Id).Returns(222);
var newDestinationItem2 = Mock.Create<IEditableRootStub>();
var savableDestinationItem2 = newDestinationItem2 as ISavable;
Mock.Arrange(() => savableDestinationItem2.Save()).Returns(savedDestinationItem2);
var newDestinationItems = new Queue<IEditableRoot>(new[] { newDestinationItem1, newDestinationItem2 });
Mock.Arrange(() => dtm.NewEditableRoot<IEditableRoot>(ReferencedProcessName)).Returns(newDestinationItems.Dequeue);
var fieldUpdater1 = Mock.Create<IFieldUpdater>();
Mock.Arrange(() => fieldUpdater1.IsKey).Returns(true);
var fieldUpdater2 = Mock.Create<IFieldUpdater>();
var fieldUpdaterFactory = Mock.Create<IFieldUpdaterFactory>();
Mock.Arrange(() => fieldUpdaterFactory.CreateFieldUpdater(ReferencedProcessName, fieldMapping1)).Returns(fieldUpdater1);
Mock.Arrange(() => fieldUpdaterFactory.CreateFieldUpdater(ReferencedProcessName, fieldMapping2)).Returns(fieldUpdater2);
var updater = new MultiCrossReferenceFieldUpdater
{
DynamicTypeManager = dtm,
FieldUpdaterFactory = fieldUpdaterFactory,
SourceDataRetrieverFactory =
new ExportFactory<IFieldMappingSourceDataRetriever>(
() => new Tuple<IFieldMappingSourceDataRetriever, Action>(sourceDataRetriever, () => { }))
};
updater.Initialize(ProcessName, mapping);
var destination = new DestinationEdit();
// Act.
updater.BeforeItemUpdate(item, null);
updater.AfterItemUpdate(item, null);
updater.Update(item, destination);
// Assert.
Assert.AreEqual(2, destination.TestField.Count);
Assert.IsTrue(destination.TestField.Any(x => x.Id == 111));
Assert.IsTrue(destination.TestField.Any(x => x.Id == 222));
Mock.Assert(() => fieldUpdater1.CalculateNewValue(sourceData1, newDestinationItem1), Occurs.Once());
Mock.Assert(() => fieldUpdater1.Update(newDestinationItem1), Occurs.Once());
Mock.Assert(() => fieldUpdater1.CalculateNewValue(sourceData2, newDestinationItem2), Occurs.Once());
Mock.Assert(() => fieldUpdater1.Update(newDestinationItem2), Occurs.Once());
Mock.Assert(() => fieldUpdater2.CalculateNewValue(sourceData1, newDestinationItem1), Occurs.Once());
Mock.Assert(() => fieldUpdater2.Update(newDestinationItem1), Occurs.Once());
Mock.Assert(() => fieldUpdater2.CalculateNewValue(sourceData2, newDestinationItem2), Occurs.Once());
Mock.Assert(() => fieldUpdater2.Update(newDestinationItem2), Occurs.Once());
Mock.Assert(() => savableDestinationItem1.Save(), Occurs.Once());
Mock.Assert(() => savableDestinationItem2.Save(), Occurs.Once());
}
public void UpdateCanRemoveItems()
{
// Arrange.
const string ProcessName = "TestProcess";
const string DestinationFieldName = "TestField";
const string ReferencedProcessName = "RefProcess";
const string FieldName1 = "Field1";
const string FieldName2 = "Field2";
var dataSourceDefinition = new FieldMappingDataSourceDefinition("Test Data Source", ProcessName, "TestProperty", true, true, true);
var fieldMapping1 = new DataTriggerFieldMapping(FieldName1, true, (s, d) => null);
var fieldMapping2 = new DataTriggerFieldMapping(FieldName2, false, (s, d) => null);
var mapping = new DataTriggerListFieldMapping(
new[] { dataSourceDefinition }, DestinationFieldName, DataTriggerModificationType.Remove, new[] { fieldMapping1, fieldMapping2 });
var item = Mock.Create<IEditableRoot>();
var sourceData1 = new DataTriggerSourceData();
var sourceData2 = new DataTriggerSourceData();
var sourceData3 = new DataTriggerSourceData();
var sourceDataRetriever = Mock.Create<IFieldMappingSourceDataRetriever>();
Mock.Arrange(() => sourceDataRetriever.GetSourceData(item, null)).Returns(() => new[] { sourceData1, sourceData2, sourceData3 });
var oldDestinationItem1 = Mock.Create<IEditableRoot>();
Mock.Arrange(() => oldDestinationItem1.Id).Returns(111);
var oldDestinationItem2 = Mock.Create<IEditableRoot>();
Mock.Arrange(() => oldDestinationItem2.Id).Returns(222);
var destination = new DestinationEdit();
destination.TestField.Assign(oldDestinationItem1.Id);
destination.TestField.Assign(oldDestinationItem2.Id);
Mock.Arrange(() => _dtm.GetEditableRootType(ProcessName)).Returns(typeof(DestinationEdit));
SetupGetEditableRoot(ReferencedProcessName, oldDestinationItem1, oldDestinationItem2);
var fieldUpdater1 = Mock.Create<IFieldUpdater>();
Mock.Arrange(() => fieldUpdater1.IsKey).Returns(true);
var fieldUpdater2 = Mock.Create<IFieldUpdater>();
var fieldUpdaterFactory = Mock.Create<IFieldUpdaterFactory>();
Mock.Arrange(() => fieldUpdaterFactory.CreateFieldUpdater(ReferencedProcessName, fieldMapping1)).Returns(fieldUpdater1);
Mock.Arrange(() => fieldUpdaterFactory.CreateFieldUpdater(ReferencedProcessName, fieldMapping2)).Returns(fieldUpdater2);
Mock.Arrange(() => fieldUpdater1.AreEqual(sourceData1, oldDestinationItem1)).Returns(true);
var updater = new MultiCrossReferenceFieldUpdater
{
DynamicTypeManager = _dtm,
FieldUpdaterFactory = fieldUpdaterFactory,
SourceDataRetrieverFactory =
new ExportFactory<IFieldMappingSourceDataRetriever>(
() => new Tuple<IFieldMappingSourceDataRetriever, Action>(sourceDataRetriever, () => { }))
};
updater.Initialize(ProcessName, mapping);
// Act.
updater.BeforeItemUpdate(item, null);
updater.AfterItemUpdate(item, null);
updater.Update(item, destination);
// Assert.
Assert.AreEqual(1, destination.TestField.Count);
Assert.IsTrue(destination.TestField.Any(x => x.Id == 222));
}
public void CreateFieldUpdaterTest()
{
// Arrange.
const string ProcessName = "TestProcess";
var dtm = Mock.Create<IDynamicTypeManager>();
Mock.Arrange(() => dtm.GetEditableRootType(ProcessName)).Returns(typeof(TestEdit));
var simpleMapping = new DataTriggerFieldMapping(TestsHelper.ExtractPropertyName(() => new TestEdit().Text), false, (s, d) => null);
var currentStateMapping = new DataTriggerFieldMapping(Constants.CurrentStateColumnName, false, (s, d) => null);
var fileMapping = new DataTriggerFieldMapping(TestsHelper.ExtractPropertyName(() => new TestEdit().File), false, (s, d) => null);
var singleCrossReferenceMapping = new DataTriggerFieldMapping(ReflectionHelper.GetPropertyName<TestEdit>(x => x.Person), false, null);
var sampleMapping = new DataTriggerFieldMapping(ReflectionHelper.GetPropertyName<TestEdit>(x => x.Sample), false, null);
var simpleUpdaterFactory = new ExportFactory<SimpleFieldUpdater>(
() =>
{
var u = Mock.Create<SimpleFieldUpdater>();
return new Tuple<SimpleFieldUpdater, Action>(u, () => { });
});
var fileUpdaterFactory = new ExportFactory<FileFieldUpdater>(
() =>
{
var u = Mock.Create<FileFieldUpdater>();
return new Tuple<FileFieldUpdater, Action>(u, () => { });
});
var singleCrossReferenceUpdaterFactory = new ExportFactory<SingleCrossReferenceFieldUpdater>(
() =>
{
var u = Mock.Create<SingleCrossReferenceFieldUpdater>(Behavior.Loose);
return Tuple.Create(u, new Action(() => { }));
});
var sampleUpdaterFactory = new ExportFactory<SampleFieldUpdater>(
() =>
{
var u = Mock.Create<SampleFieldUpdater>(Behavior.Loose);
return Tuple.Create(u, new Action(() => { }));
});
var factory = new FieldUpdaterFactory
{
DynamicTypeManager = dtm,
SimpleFieldUpdaterFactory = simpleUpdaterFactory,
FileFieldUpdaterFactory = fileUpdaterFactory,
SingleCrossReferenceFieldUpdaterFactory = singleCrossReferenceUpdaterFactory,
SampleFieldUpdaterFactory = sampleUpdaterFactory
};
// Act.
var simpleUpdater = (SimpleFieldUpdater)factory.CreateFieldUpdater(ProcessName, simpleMapping);
var currentStateUpdater = (SimpleFieldUpdater)factory.CreateFieldUpdater(ProcessName, currentStateMapping);
var fileUpdater = (FileFieldUpdater)factory.CreateFieldUpdater(ProcessName, fileMapping);
var singleCrossReferenceUpdater = (SingleCrossReferenceFieldUpdater)factory.CreateFieldUpdater(ProcessName, singleCrossReferenceMapping);
var sampleUpdater = (SampleFieldUpdater)factory.CreateFieldUpdater(ProcessName, sampleMapping);
// Assert.
Assert.IsNotNull(simpleUpdater);
Mock.Assert(() => simpleUpdater.Initialize(ProcessName, simpleMapping), Occurs.Once());
Assert.IsNotNull(currentStateUpdater);
Mock.Assert(() => currentStateUpdater.Initialize(ProcessName, currentStateMapping), Occurs.Once());
Assert.IsNotNull(fileUpdater);
Mock.Assert(() => fileUpdater.Initialize(ProcessName, fileMapping), Occurs.Once());
Assert.IsNotNull(singleCrossReferenceUpdater);
Mock.Assert(() => singleCrossReferenceUpdater.Initialize(ProcessName, singleCrossReferenceMapping), Occurs.Once());
Assert.IsNotNull(sampleUpdater);
Mock.Assert(() => sampleUpdater.Initialize(ProcessName, sampleMapping), Occurs.Once());
// Exceptions.
TestsHelper.VerifyThrow<ArgumentNullException>(() => factory.CreateFieldUpdater(ProcessName, null));
var invalidMapping = new DataTriggerFieldMapping("InvalidField", false, (s, d) => null);
TestsHelper.VerifyThrow<InvalidOperationException>(() => factory.CreateFieldUpdater(ProcessName, invalidMapping));
}
/// <summary>
/// Initializes the updater using a field mapping definition.
/// </summary>
/// <param name="processName">The process name.</param>
/// <param name="fieldMapping">The field mapping definition.</param>
public void Initialize(string processName, DataTriggerFieldMapping fieldMapping)
{
var type = DynamicTypeManager.GetEditableRootType(processName);
if (fieldMapping == null)
throw new ArgumentNullException("fieldMapping");
var property = type.GetPropertyByName(fieldMapping.FieldName);
if (property == null)
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" not found.", fieldMapping.FieldName));
if (!property.CanWrite)
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not writeable.", fieldMapping.FieldName));
FieldName = property.Name;
IsKey = fieldMapping.IsKey;
PropertyType = property.PropertyType;
ValueCalculator = fieldMapping.ValueCalculator;
AllowLocalizedData = property.GetCustomAttribute<AllowLocalizedDataAttribute>() != null;
if (AllowLocalizedData)
{
SupportedLocalizations.AddRange(property.DeclaringType.GetCustomAttributes<LocalizationInfoAttribute>());
}
}
private FileFieldUpdater CreateFileFieldUpdater(string processName, DataTriggerFieldMapping fieldMapping)
{
var updater = FileFieldUpdaterFactory.CreateExport().Value;
updater.Initialize(processName, fieldMapping);
return updater;
}
