public void InitializeTest()
{
// Arrange.
var sourceDefinition1 = new FieldMappingDataSourceDefinition("Source 1", "TestProcess", "Property1", true, false, false);
var sourceDefinition2 = new FieldMappingDataSourceDefinition("Source 2", "TestProcess", "Property2", true, false, false);
var source1 = Mock.Create<IFieldMappingDataSource>();
var source2 = Mock.Create<IFieldMappingDataSource>();
var newSources = new Queue<IFieldMappingDataSource>(new[] { source1, source2 });
var retriever = new FieldMappingSourceDataRetriever
{
DataSourceFactory =
new ExportFactory<IFieldMappingDataSource>(() => new Tuple<IFieldMappingDataSource, Action>(newSources.Dequeue(), () => { }))
};
// Act.
retriever.Initialize(new[] { sourceDefinition1, sourceDefinition2 });
// Assert.
Assert.AreEqual(2, retriever.DataSources.Count);
Assert.IsTrue(retriever.DataSources.Contains(source1));
Assert.IsTrue(retriever.DataSources.Contains(source2));
Mock.Assert(() => source1.Initialize(sourceDefinition1), Occurs.Once());
Mock.Assert(() => source2.Initialize(sourceDefinition2), Occurs.Once());
// Exceptions.
TestsHelper.VerifyThrow<ArgumentNullException>(() => retriever.Initialize(null));
}
/// <summary>
/// Creates a source items retriever from a data source definition.
/// </summary>
/// <param name="dataSource">The data source definition.</param>
/// <returns>Returns a source items retriever.</returns>
/// <exception cref="System.ArgumentNullException">dataSource</exception>
public ISourceItemsRetriever CreateItemsRetriever(FieldMappingDataSourceDefinition dataSource)
{
if (dataSource == null)
throw new ArgumentNullException("dataSource");
return CreateItemsRetrieverFromPropertyPath(dataSource.ProcessName, dataSource.PropertyPath);
}
public void GetItemsCanReturnOldItems()
{
// Arrange.
var dsDefinition = new FieldMappingDataSourceDefinition("Test Data Source", "TestProcess", "Property1.Property2", false, true, false);
var newItem1 = Mock.Create<IEditableRoot>();
Mock.Arrange(() => newItem1.Id).Returns(1);
var newItem2 = Mock.Create<IEditableRoot>();
Mock.Arrange(() => newItem2.Id).Returns(2);
var oldItem1 = Mock.Create<IEditableRoot>();
Mock.Arrange(() => oldItem1.Id).Returns(1);
var oldItem2 = Mock.Create<IEditableRoot>();
Mock.Arrange(() => oldItem2.Id).Returns(3);
var removedItem1 = Mock.Create<IEditableRoot>();
Mock.Arrange(() => removedItem1.Id).Returns(1);
var removedItem2 = Mock.Create<IEditableRoot>();
Mock.Arrange(() => removedItem2.Id).Returns(4);
var item = Mock.Create<IEditableRoot>();
var oldItem = Mock.Create<IEditableRoot>();
var itemsRetriever = Mock.Create<ISourceItemsRetriever>();
Mock.Arrange(() => itemsRetriever.GetNewItems(item, oldItem)).Returns(() => new[] { newItem1, newItem2 });
Mock.Arrange(() => itemsRetriever.GetOldItems(item, oldItem)).Returns(() => new[] { oldItem1, oldItem2 });
Mock.Arrange(() => itemsRetriever.GetRemovedItems(item, oldItem)).Returns(() => new[] { removedItem1, removedItem2 });
var itemsRetrieverFactory = Mock.Create<ISourceItemsRetrieverFactory>();
Mock.Arrange(() => itemsRetrieverFactory.CreateItemsRetriever(dsDefinition)).Returns(itemsRetriever);
var ds = new FieldMappingDataSource { ItemsRetrieverFactory = itemsRetrieverFactory };
ds.Initialize(dsDefinition);
// Act.
var result = ds.GetItems(item, oldItem).ToArray();
// Assert.
Assert.AreEqual(2, result.Length);
Assert.IsTrue(result.Contains(oldItem1));
Assert.IsTrue(result.Contains(oldItem2));
}
/// <summary>
/// Initializes the data source from a data source definition.
/// </summary>
/// <param name="definition">A data source definition.</param>
/// <exception cref="System.ArgumentNullException">definition</exception>
/// <exception cref="ArgumentNullException">The definition parameter is null.</exception>
public void Initialize(FieldMappingDataSourceDefinition definition)
{
if (definition == null)
throw new ArgumentNullException("definition");
_name = definition.Name;
ItemsRetriever = ItemsRetrieverFactory.CreateItemsRetriever(definition);
IncludeNewItems = definition.IncludeNewItems;
IncludeOldItmes = definition.IncludeOldItems;
IncludeRemovedItems = definition.IncludeRemovedItmes;
}
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 CreateItemsRetrieverTest()
{
// Arrange.
var dtm = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
Mock.Arrange(() => dtm.GetEditableRootType(ProcessName1)).Returns(typeof(TestEdit1));
Mock.Arrange(() => dtm.GetEditableRootType(ProcessName2)).Returns(typeof(TestEdit2));
Mock.Arrange(() => dtm.GetEditableRootType(ProcessName3)).Returns(typeof(TestEdit3));
var singleCrossReferenceFactory = new ExportFactory<SingleCrossReferenceSourceItemsRetriever>(
() =>
{
var r = Mock.Create<SingleCrossReferenceSourceItemsRetriever>(Behavior.Loose);
Mock.Arrange(() => r.Initialize(ProcessName1, TestsHelper.ExtractPropertyName(() => new TestEdit1().CR1)))
.DoInstead(() => Mock.Arrange(() => r.ReferencedProcess).Returns(ProcessName2));
Mock.Arrange(() => r.Initialize(ProcessName2, TestsHelper.ExtractPropertyName(() => new TestEdit2().CR2)))
.DoInstead(() => Mock.Arrange(() => r.ReferencedProcess).Returns(ProcessName3));
return new Tuple<SingleCrossReferenceSourceItemsRetriever, Action>(r, () => { });
});
var multiCrossReferenceFactory = new ExportFactory<MultiCrossReferenceSourceItemsRetriever>(
() =>
{
var r = Mock.Create<MultiCrossReferenceSourceItemsRetriever>(Behavior.Loose);
Mock.Arrange(() => r.Initialize(ProcessName1, TestsHelper.ExtractPropertyName(() => new TestEdit1().MultiCR1)))
.DoInstead(() => Mock.Arrange(() => r.ReferencedProcess).Returns(ProcessName2));
Mock.Arrange(() => r.Initialize(ProcessName2, TestsHelper.ExtractPropertyName(() => new TestEdit2().MultiCR2)))
.DoInstead(() => Mock.Arrange(() => r.ReferencedProcess).Returns(ProcessName3));
return new Tuple<MultiCrossReferenceSourceItemsRetriever, Action>(r, () => { });
});
var factory = new SourceItemsRetrieverFactory
{
DynamicTypeManager = dtm,
SingleCrossReferenceSourceItemsRetrieverFactory = singleCrossReferenceFactory,
MultiCrossReferenceSourceItemsRetrieverFactory = multiCrossReferenceFactory
};
var dataSource1 = new FieldMappingDataSourceDefinition(
"Source 1",
ProcessName1,
TestsHelper.ExtractPropertyName(() => new TestEdit1().CR1) + "." + TestsHelper.ExtractPropertyName(() => new TestEdit2().CR2),
true,
true,
true);
var dataSource2 = new FieldMappingDataSourceDefinition(
"Source 2",
ProcessName1,
TestsHelper.ExtractPropertyName(() => new TestEdit1().CR1) + "." + TestsHelper.ExtractPropertyName(() => new TestEdit2().MultiCR2),
true,
true,
true);
var dataSource3 = new FieldMappingDataSourceDefinition(
"Source 3",
ProcessName1,
TestsHelper.ExtractPropertyName(() => new TestEdit1().MultiCR1) + "." + TestsHelper.ExtractPropertyName(() => new TestEdit2().CR2),
true,
true,
true);
var dataSource4 = new FieldMappingDataSourceDefinition(
"Source 4",
ProcessName1,
TestsHelper.ExtractPropertyName(() => new TestEdit1().MultiCR1) + "." + TestsHelper.ExtractPropertyName(() => new TestEdit2().MultiCR2),
true,
true,
true);
// Act.
var retriever1 = (SingleCrossReferenceSourceItemsRetriever)factory.CreateItemsRetriever(dataSource1);
var innerRetriever1 = (SingleCrossReferenceSourceItemsRetriever)retriever1.Subretriever;
var retriever2 = (SingleCrossReferenceSourceItemsRetriever)factory.CreateItemsRetriever(dataSource2);
var innerRetriever2 = (MultiCrossReferenceSourceItemsRetriever)retriever2.Subretriever;
var retriever3 = (MultiCrossReferenceSourceItemsRetriever)factory.CreateItemsRetriever(dataSource3);
var innerRetriever3 = (SingleCrossReferenceSourceItemsRetriever)retriever3.Subretriever;
var retriever4 = (MultiCrossReferenceSourceItemsRetriever)factory.CreateItemsRetriever(dataSource4);
var innerRetriever4 = (MultiCrossReferenceSourceItemsRetriever)retriever4.Subretriever;
// Assert.
Assert.IsNotNull(retriever1);
Mock.Assert(() => retriever1.Initialize(ProcessName1, TestsHelper.ExtractPropertyName(() => new TestEdit1().CR1)), Occurs.Once());
Assert.IsNotNull(innerRetriever1);
Mock.Assert(() => innerRetriever1.Initialize(ProcessName2, TestsHelper.ExtractPropertyName(() => new TestEdit2().CR2)), Occurs.Once());
Assert.IsNull(innerRetriever1.Subretriever);
Assert.IsNotNull(retriever2);
Mock.Assert(() => retriever2.Initialize(ProcessName1, TestsHelper.ExtractPropertyName(() => new TestEdit1().CR1)), Occurs.Once());
Assert.IsNotNull(innerRetriever2);
Mock.Assert(() => innerRetriever2.Initialize(ProcessName2, TestsHelper.ExtractPropertyName(() => new TestEdit2().MultiCR2)), Occurs.Once());
Assert.IsNull(innerRetriever2.Subretriever);
Assert.IsNotNull(retriever3);
Mock.Assert(() => retriever3.Initialize(ProcessName1, TestsHelper.ExtractPropertyName(() => new TestEdit1().MultiCR1)), Occurs.Once());
Assert.IsNotNull(innerRetriever3);
Mock.Assert(() => innerRetriever3.Initialize(ProcessName2, TestsHelper.ExtractPropertyName(() => new TestEdit2().CR2)), Occurs.Once());
Assert.IsNull(innerRetriever3.Subretriever);
Assert.IsNotNull(retriever4);
Mock.Assert(() => retriever4.Initialize(ProcessName1, TestsHelper.ExtractPropertyName(() => new TestEdit1().MultiCR1)), Occurs.Once());
Assert.IsNotNull(innerRetriever4);
Mock.Assert(() => innerRetriever4.Initialize(ProcessName2, TestsHelper.ExtractPropertyName(() => new TestEdit2().MultiCR2)), Occurs.Once());
Assert.IsNull(innerRetriever4.Subretriever);
}
