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));
        }
        public void GetSourceDataShouldReturnTheCartesianProductOfAllDataSources()
        {
            // Arrange.
            var item = Mock.Create<IEditableRoot>();
            var oldItem = Mock.Create<IEditableRoot>();

            var item11 = Mock.Create<IEditableRoot>();
            var item12 = Mock.Create<IEditableRoot>();
            var source1 = Mock.Create<IFieldMappingDataSource>();
            Mock.Arrange(() => source1.Name).Returns("Source 1");
            Mock.Arrange(() => source1.GetItems(item, oldItem)).Returns(() => new[] { item11, item12 });

            var item21 = Mock.Create<IEditableRoot>();
            var item22 = Mock.Create<IEditableRoot>();
            var source2 = Mock.Create<IFieldMappingDataSource>();
            Mock.Arrange(() => source2.Name).Returns("Source 2");
            Mock.Arrange(() => source2.GetItems(item, oldItem)).Returns(() => new[] { item21, item22 });

            var item31 = Mock.Create<IEditableRoot>();
            var item32 = Mock.Create<IEditableRoot>();
            var source3 = Mock.Create<IFieldMappingDataSource>();
            Mock.Arrange(() => source3.Name).Returns("Source 3");
            Mock.Arrange(() => source3.GetItems(item, oldItem)).Returns(() => new[] { item31, item32 });

            var retriever = new FieldMappingSourceDataRetriever();
            retriever.DataSources.Add(source1);
            retriever.DataSources.Add(source2);
            retriever.DataSources.Add(source3);

            // Act.
            var result = retriever.GetSourceData(item, oldItem).ToArray();

            // Assert.
            Assert.AreEqual(8, result.Length);

            Func<IEditableRoot, IEditableRoot, IEditableRoot, bool> contains =
                (i1, i2, i3) => result.Any(x => x.SourceItems["Source 1"] == i1 && x.SourceItems["Source 2"] == i2 && x.SourceItems["Source 3"] == i3);

            Assert.IsTrue(contains(item11, item21, item31));
            Assert.IsTrue(contains(item12, item21, item31));
            Assert.IsTrue(contains(item11, item22, item31));
            Assert.IsTrue(contains(item12, item22, item31));
            Assert.IsTrue(contains(item11, item21, item32));
            Assert.IsTrue(contains(item12, item21, item32));
            Assert.IsTrue(contains(item11, item22, item32));
            Assert.IsTrue(contains(item12, item22, item32));
        }